用java实现线程池的一个简单示例

转载：http://hi.baidu.com/triceratops/blog

public class ThreadPoolManager{
private static ThreadPoolManager poolManager;
private ThreadPool pool;

static final int POOL_MIN_SIZE = 1;
static final int POOL_MAX_SIZE = 10;

private ThreadPoolManager(){
   pool = new ThreadPool(POOL_MIN_SIZE,POOL_MAX_SIZE);
}

public synchronized static ThreadPoolManager getInstance() {
   if(poolManager == null)
    poolManager = new ThreadPoolManager();
   return poolManager;
}

//Get the working thread
private ThreadWorker getWorker(){
   return pool.getWorker();
}

public void doService(String jobName){
   getWorker().ready(jobName);
}
}

===================================

import java.util.Stack;

class ThreadPool{
private int poolMinSize;
private int poolMaxSize;
private int accumulator = 0;
private Stack pool;

ThreadPool(int poolMinSize,int poolMaxSize){
   this.poolMinSize = poolMinSize;
   this.poolMaxSize = poolMaxSize;
   pool = new Stack();
   initializePool();
}

private void initializePool(){
   ThreadWorker worker;
   for(int i=0;i<poolMinSize;i++){
    worker = new ThreadWorker(this,i+1);
    pool.push(worker);
    accumulator++;
    worker.start();
   }
}

public synchronized ThreadWorker getWorker(){
   while(true){
    if(!pool.isEmpty()){
     return (ThreadWorker)pool.pop();
    }
    else{
     if(accumulator == poolMaxSize){
      try{
       wait(); //main thread hangs up
      }
      catch(InterruptedException e){
       e.printStackTrace();
      }
     }
     else{
      ThreadWorker worker = new ThreadWorker(this);
      worker.start();
      accumulator++;
      return worker;
     }
    }
   }
}

public synchronized boolean returnWorker(ThreadWorker worker){
   if(pool.size() < poolMaxSize){
    pool.push(worker);
    System.out.println(worker+" has been returned!");
    notify();
    return true;
   }
   return false; // The thread pool is full filled.
}
}

===================================

class ThreadWorker extends Thread{
private ThreadPool pool;
private int workerId;
private String jobName;

private static int newAddWorkerId = ThreadPoolManager.POOL_MIN_SIZE + 1;

public ThreadWorker(ThreadPool pool){
   this.pool = pool;
   workerId = newAddWorkerId++;
}

public ThreadWorker(ThreadPool pool,int workerId){
   this.pool = pool;
   this.workerId = workerId;
}

public synchronized void ready(String jobName){
   this.jobName = jobName;
   notify();
}

public synchronized void run(){
   while(true){
    if(jobName == null){
     try{
      wait();
     }
     catch(InterruptedException e){
      e.printStackTrace();
     }
    }
    Job job = new Job(jobName);
    //main function
    job.execute(workerId);
    jobName = null;
    if(!pool.returnWorker(this))
     break;
   }
}

public String toString(){
   return "Worker "+workerId;
}
}

===================================

class Job {
private String jobName;

public Job(String jobName){
   this.jobName = jobName;
}
public void execute(int workerId){
   System.out.println("No."+workerId+" is doing the job '"+jobName+"'");
   try{
    Thread.sleep(500);
   }
   catch(InterruptedException e){
    e.printStackTrace();
   }
}
}