100分求线程池示例

Question

服务器准备用TOMCAT 
一个主线程  负责初始化参数  
需要一个线程池 大概10个子线程 得到初始化后的参数  执行响应操作。这个线程池怎么写？

Answer 1

不知道楼主想要的线程池是不是数据库连接池
tomcat有自己的数据库连接池
只要在conf目录下的context.xml
中配一个Resource就可以了
以SqlServer为例
<Resource name="数据库连接池名称"
auth="Container"
type="javax.sql.DataSource"
maxActive="100"
maxIdle="30"
maxWait="10000"
username="sa"
password="sa"
driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
url="jdbc:microsoft:sqlserver://localhost:1433;databasename=数据库名称"/>
只要把这个<Resource>标签加到<Context>标签中就可以了

Answer 2

http://dev.csdn.net/article/45/45270.shtm

Answer 3

  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){
                       }
                  }
                  synchronized(o){
                    freeThreadCount--;
                  }
                  work = (String)m_RunList.removeLast();
                  if(work==null) return;
                }
  // 得到了work 进行工作，这里work可以换成自己的工作类
              }
            }
}
}
        /**
         *
         * <p>Title: 定时器调动的任务</p>
         * @author 张荣斌
         * @version 1.0
         */
        class CheckThreadTask extends TimerTask{
          private static boolean isRunning = false;
          private ThreadPool pool;
          public CheckThreadTask(ThreadPool pool){
            this.pool = pool;
          }
          public void run() {
            if (!isRunning)  {
              isRunning = true;
              pool.checkAllThreads();
              isRunning = false;
            }
          }
        }

Answer 4

没有我希望中的东西
3楼朋友发的代码  我之前就BAIDU出来了
http://www.bitscn.com/java/lines/200605/21582.html