public interface ThreadPool<Job extends Runnable>{
  //執(zhí)行一個任務(Job),這個Job必須實現(xiàn)Runnable
  void execute(Job job);
 //關閉線程池
 void shutdown();
 //增加工作者線程，即用來執(zhí)行任務的線程
 void addWorkers(int num);
 //減少工作者線程
 void removeWorker(int num);
 //獲取正在等待執(zhí)行的任務數(shù)量
 void getJobSize();
}

public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job>{

  // 線程池維護工作者線程的最大數(shù)量
  private static final int MAX_WORKER_NUMBERS = 10;
  // 線程池維護工作者線程的默認值
  private static final int DEFAULT_WORKER_NUMBERS = 5;
  // 線程池維護工作者線程的最小數(shù)量
  private static final int MIN_WORKER_NUMBERS = 1;
  // 維護一個工作列表,里面加入客戶端發(fā)起的工作
  private final LinkedList<Job> jobs = new LinkedList<Job>();
  // 工作者線程的列表
  private final List<Worker> workers = Collections.synchronizedList(new ArrayList<Worker>());
  // 工作者線程的數(shù)量
  private int workerNum;
  // 每個工作者線程編號生成
  private AtomicLong threadNum = new AtomicLong();

 //生成線程池
public DefaultThreadPool() {
    this.workerNum = DEFAULT_WORKER_NUMBERS;
    initializeWorkers(this.workerNum);
  }

  public DefaultThreadPool(int num) {
    if (num > MAX_WORKER_NUMBERS) {
      this.workerNum =DEFAULT_WORKER_NUMBERS;
    } else {
      this.workerNum = num;
    }
    initializeWorkers(this.workerNum);
  }
//初始化每個工作者線程
private void initializeWorkers(int num) {
    for (int i = 0; i < num; i++) {
      Worker worker = new Worker();
      //添加到工作者線程的列表
      workers.add(worker);
      //啟動工作者線程
      Thread thread = new Thread(worker);
      thread.start();
    }
  }

public void execute(Job job) {
    if (job != null) {
    //根據線程的"等待/通知機制"這里必須對jobs加鎖
      synchronized (jobs) {
        jobs.addLast(job);
        jobs.notify();
      }
    }
  }
  //關閉線程池即關閉每個工作者線程
   public void shutdown() {
    for (Worker w : workers) {
      w.shutdown();
    }
  }
   //增加工作者線程
    public void addWorkers(int num) {
    //加鎖，防止該線程還么增加完成而下個線程繼續(xù)增加導致工作者線程超過最大值
    synchronized (jobs) {
      if (num + this.workerNum > MAX_WORKER_NUMBERS) {
        num = MAX_WORKER_NUMBERS - this.workerNum;
      }
      initializeWorkers(num);
      this.workerNum += num;
    }
  }
  //減少工作者線程
public void removeWorker(int num) {
    synchronized (jobs) {
    if(num>=this.workerNum){
         throw new IllegalArgumentException("超過了已有的線程數(shù)量");
         }
      for (int i = 0; i < num; i++) {
        Worker worker = workers.get(i);
        if (worker != null) {
        //關閉該線程并從列表中移除
          worker.shutdown();
          workers.remove(i);
        }
      }
      this.workerNum -= num;
    }
  }

public int getJobSize() {
    // TODO Auto-generated method stub
    return workers.size();
  }
//定義工作者線程
class Worker implements Runnable {
    // 表示是否運行該worker
    private volatile boolean running = true;

    public void run() {
      while (running) {
        Job job = null;
        //線程的等待/通知機制
        synchronized (jobs) {
          if (jobs.isEmpty()) {
            try {
              jobs.wait();//線程等待喚醒
            } catch (InterruptedException e) {
              //感知到外部對該線程的中斷操作，返回
              Thread.currentThread().interrupt();
              return;
            }
          }
          // 取出一個job
          job = jobs.removeFirst();
        }
        //執(zhí)行job
        if (job != null) {
          job.run();
        }
      }
    }

    // 終止該線程
    public void shutdown() {
      running = false;
    }
  }
}