典型Java线程池的代码及其各部分功能介绍

个人博客已经迁移到如下网站 萌萌的IT人, 后续所有的文章都会在此发布

 

 

----------------------------------------------------------------------------------

（1）根据xml文件来管理线程池的最大最小线程数
　　（2）对线程池通过Timer定期扫描以防止线程未激活；
　　（3）通过某一个变量（本程序中是freeThreadCount）来得到空闲线程的数目；

一、配置xml（listen.xml）是：
　　<?xml version="1.0" encoding="UTF-8"?>
　　<config>
　　<ConsumeThreadPool>
　　<minPools>10</minPools>　　　<!--线程池最小线程-->
　　<maxPools>100</maxPools>　　　　<!--线程池最大线程-->
　　<checkThreadPeriod>5</checkThreadPeriod>　<!--检查线程池中线程的周期5分钟-->
　　</ConsumeThreadPool>
　　</config>

　二、对于ConsumeThreadPoolPara的javabean: 
　　import java.io.*;
　　public class ConsumeThreadPoolPara implements Serializable{
　　private int minPools;
　　private int maxPools;
　　private int checkThreadPeriod;
　　
　　public int getMinPools(){
　　return minPools;
　　}
　　public int getMaxPools(){
　　return maxPools;
　　}
　　public int getCheckThreadPeriod(){
　　return checkThreadPeriod;
　　}
　　public void setMinPools(int minPools){
　　this.minPools = minPools;
　　}
　　public void setMaxPools(int maxPools){
　　this.maxPools = maxPools;
　　}
　　public void setCheckThreadPeriod(int checkThreadPeriod){
　　this.checkThreadPeriod = checkThreadPeriod;
　　}
　　public String toString(){
　　return minPools+" " + maxPools+" "+checkThreadPeriod;
　　}
　　public ConsumeThreadPoolPara() {
　　}
　　public static void main(String[] args) {
　　ConsumeThreadPoolPara consumeThreadPool1 = new ConsumeThreadPoolPara();
　　}
　　
　　}
　　
　　三、解析xml程序代码（生成ConsumeThreadPoolPara）：
　　使用jdom解析：
　　import org.jdom.*;
　　import org.jdom.input.SAXBuilder;
　　import java.io.*;
　　import java.util.*;
　　
　　public class ParseConfig {
　　static Hashtable Listens = null;
　　static ConnPara connpara = null;
　　static ConsumeThreadPoolPara consumeThreadPoolPara = null;
　　private static String configxml = "listen.xml";
　　
　　static{
　　getConsumeThreadPoolPara();　//得到消费的线程池的参数
　　}
　　
　　/**
　　* 装载文档
　　* @return 返回根结点
　　* @throws JDOMException
　　*/
　　public static Element loadDocument() throws JDOMException{
　　SAXBuilder parser = new SAXBuilder(); // 新建立构造器
　　try {
　　Document document = parser.build(configxml);
　　Element root = document.getRootElement();
　　return root;
　　}catch(JDOMException e){
　　logger.error("listen.xml文件格式非法！");
　　throw new JDOMException();
　　}
　　}
　　
　　public static ConsumeThreadPoolPara getConsumeThreadPoolPara(){
　　if(consumeThreadPoolPara ==null){
　　try {
　　Element root = loadDocument();
　　Element consumeThreadPool = root.getChild("ConsumeThreadPool");
　　if (consumeThreadPool != null) { //代表有数据库配置
　　consumeThreadPoolPara = new ConsumeThreadPoolPara();
　　Element minPools = consumeThreadPool.getChild("minPools");
　　consumeThreadPoolPara.setMinPools(Integer.parseInt(minPools.getTextTrim()));
　　Element maxPools = consumeThreadPool.getChild("maxPools");
　　consumeThreadPoolPara.setMaxPools(Integer.parseInt(maxPools.getTextTrim()));
　　Element checkThreadPeriod = consumeThreadPool.getChild("checkThreadPeriod");
　　consumeThreadPoolPara.setCheckThreadPeriod(Integer.parseInt(checkThreadPeriod.getTextTrim()));
　　}
　　}
　　catch (JDOMException e) {
　　}
　　}
　　return consumeThreadPoolPara;
　　}
　　}
　　
　　四、线程池源代码：
　　import java.util.*;
　　
　　/**
　　* <p>Title: 线程池</p>
　　* <p>Description: 采集消费模块</p>
　　* <p>Copyright: Copyright (c) 2004</p>
　　* <p>Company: </p>
　　* @author 张荣斌
　　* @version 1.0
　　*/
　　
　　public class ThreadPool {
　　private static int minPools = 10; //最小连接池数目
　　private static int maxPools = 100; //最大连接池数目
　　private static int checkThreadPeriod = 5; //检查连接池的周期
　　ArrayList m_ThreadList;　//工作线程列表
　　LinkedList m_RunList = null;　//工作任务列表
　　int totalThread = 0;　//总线程数
　　static int freeThreadCount = 0;　//未被使用的线程数目
　　private java.util.Timer timer = null;　//定时器
　　static Object o = new Object();
　　
　　static{　//先初始化线程池的参数
　　ConsumeThreadPoolPara consumeThreadPoolPara = ParseConfig.getConsumeThreadPoolPara();
　　if(consumeThreadPoolPara!=null){
　　minPools = consumeThreadPoolPara.getMinPools();
　　maxPools = consumeThreadPoolPara.getMaxPools();
　　checkThreadPeriod = consumeThreadPoolPara.getCheckThreadPeriod()*60*1000;
　　}
　　}
　　public void setMinPools(int minPools){
　　this.minPools = minPools;
　　}
　　public void setMaxPools(int maxPools){
　　this.maxPools = maxPools;
　　}
　　public void setCheckThreadPeriod(int checkThreadPeriod){
　　this.checkThreadPeriod = checkThreadPeriod;
　　}
　　public ThreadPool() {
　　
　　m_ThreadList=new ArrayList();
　　m_RunList=new LinkedList();
　　for(int i=0;i<minPools;i++){
　　WorkerThread temp=new WorkerThread();
　　totalThread = totalThread + 1;
　　m_ThreadList.add(temp);
　　temp.start();
　　try{
　　Thread.sleep(100);
　　}catch(Exception e){
　　}
　　}
　　timer = new Timer(true);　//启动定时器
　　timer.schedule(new CheckThreadTask(this),0,checkThreadPeriod);
　　}
　　
　　/**
　　* 当有一个工作来的时候启动线程池的线程
　　* 1.当空闲线程数为0的时候，看总线程是否小于最大线程池的数目，就new一个新的线程，否则sleep，直到有空闲线程为止;
　　* 2.当空闲线程不为0，则将任务丢给空闲线程去完成
　　* @param work
　　*/
　　public synchronized void run(String work)
　　{
　　if (freeThreadCount == 0) {
　　if(totalThread<maxPools){
　　WorkerThread temp = new WorkerThread();
　　totalThread = totalThread + 1;
　　m_ThreadList.add(temp);
　　temp.start();
　　synchronized(m_RunList){
　　m_RunList.add(work);
　　m_RunList.notify();
　　}
　　}else{
　　while (freeThreadCount == 0) {
　　try {
　　Thread.sleep(200);
　　}
　　catch (InterruptedException e) {
　　}
　　}
　　synchronized(m_RunList){
　　m_RunList.add(work);
　　m_RunList.notify();
　　}
　　}
　　} else {
　　synchronized(m_RunList){
　　m_RunList.add(work);
　　m_RunList.notify();
　　}
　　}
　　}
　　
　　/**
　　* 检查所有的线程的有效性
　　*/
　　public synchronized void checkAllThreads() {
　　
　　Iterator lThreadIterator = m_ThreadList.iterator();
　　
　　while (lThreadIterator.hasNext()) { //逐个遍厉
　　WorkerThread lTestThread = (WorkerThread) lThreadIterator.next();
　　
　　if (! (lTestThread.isAlive())) { //如果处在非活动状态时
　　lTestThread = new WorkerThread(); //重新生成个线程
　　lTestThread.start(); //启动
　　}
　　}
　　}
　　
　　/**
　　* 打印调试信息
　　*/
　　public void printDebugInfo(){
　　System.out.println("totalThread="+totalThread);
　　System.out.println("m_ThreadList.size()="+m_ThreadList.size());
　　}
　　
　　/**
　　*
　　* <p>Title: 工作线程类</p>
　　* @author 张荣斌
　　* @version 1.0
　　*/
　　class WorkerThread extends Thread{
　　boolean running = true;
　　String work;
　　
　　public void run(){
　　while(running){
　　synchronized(o){
　　freeThreadCount++;
　　}
　　synchronized(m_RunList){
　　while(m_RunList.size() == 0){
　　try{
　　m_RunList.wait();
　　if(!running) return;
　　}catch(InterruptedException e){
　　}< 

文章转载自网管网：http://www.bitscn.com/plus/view.php?aid=21582