二 Java利用等待/通知机制实现一个线程池

接着上一篇博客的 一Java线程的等待/通知模型 ，没有看过的建议先看一下。下面我们用等待通知机制来实现一个线程池.

本文的代码放到了github上,地址如下: git@github.com:jiulu313/ThreadPool.git

线程的任务就以打印一行文本来模拟耗时的任务。主要代码如下：

1  定义一个任务的接口。

 /*
  * 任务的接口
  */
 public interface Task {
     void doSomething();
 }

2  实现一个具体的任务。

 /*
  * 具体的任务
  */
 public class PrintTask implements Task{

     //打印一句话，睡一秒，来模拟耗时的任务
     @Override
     public void doSomething() {
         System.out.println("任务："+Thread.currentThread().getName());
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

3  实现工作线程

 /*
  * 工作者线程
  */
 public class Worker implements Runnable {
     //线程是否正在运行
     private boolean running = true;        

     //保存Thread，方便start()
     private Thread thread;

     //保存线程池的任务队列，作同步用
     private LinkedList<Task> tasks;

     public void setThread(Thread thread) {
         this.thread = thread;
     }

     public void setTasks(LinkedList<Task> tasks) {
         this.tasks = tasks;
     }

     //启动此工作线程
     public void start() {
         if (thread != null) {
             thread.start();
         }
     }

     // 关闭此工作线程
     public void shutDown() {
         running = false;
         thread.interrupt();
     }

     @Override
     public void run() {
         while (running) {
             Task task = null;

             //对共享变量加锁，此处为任务队列，因为会有多个线程访问
             synchronized (tasks) {

                 //当条件不满足时，线程等待，见上一篇博文
                 while (tasks.isEmpty()) {
                     try {
                         //线程进入等待状态，并且释放锁
                         tasks.wait();
                     } catch (InterruptedException e) {
                         //感知到外部对此线程的中断操作
                         Thread.currentThread().interrupt();
                         return;
                     }
                 }

                 //条件满足
                 task = tasks.removeFirst();
             }

             //执行任务
             if (task != null) {
                 task.doSomething();
             }
         }
     }
 }

4  创建一个线程池

 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;

 public class DefaultThreadPool implements ThreadPool {
     private int maxWorksNum = 10;
     private int minWorksNum = 1;
     private int defaultWorksNum = 5;

     // 任务列表
     private LinkedList<Task> tasks = new LinkedList<>();

     // 工作线程列表
     private LinkedList<Worker> workers = new LinkedList<>();

     //工作线程个数
     private int workerNum = defaultWorksNum;

     @Override
     public void excute(Task task) {
         // 添加一个工作，然后进行通知
         if (task != null) {
             synchronized (tasks) {
                 //添加到最后一个位置
                 tasks.addLast(task);
                 //通知等待的线程，有新的任务了
                 tasks.notify();
             }
         }
     }

     // 关闭线程池
     @Override
     public void shutDown() {
         for (Worker worker : workers) {
             worker.shutDown();
         }
     }

     // 初始化工作者线程
     public void initWorkers(int num) {
         if (num > maxWorksNum) {
             num = maxWorksNum;
         } else if (num < minWorksNum) {
             num = minWorksNum;
         } else {
             num = defaultWorksNum;
         }

         for (int i = 0; i < workerNum; i++) {
             //创建工作线程
             Worker worker = new Worker();

             //添加到工作队列
             workers.add(worker);

             //新建一个线程对象，并将worker赋值
             Thread thread = new Thread(worker);

             //设置线程对象，作启动，中断用
             worker.setThread(thread);

             //设置任务队列，作同步用
             worker.setTasks(tasks);
         }
     }

     // 启动线程池
     public void start(){
         if(workers != null){
             for(Worker worker : workers){
                 //启动一个工作线程
                 worker.start();
             }
         }
     }

     // 新增加工作线程,但是不能大于线程池最大线程数
     @Override
     public void addWorkers(int num) {
         if (num <= 0) {
             return;
         }

         int remain = maxWorksNum - workerNum;
         if (num > remain) {
             num = remain;
         }

         for (int i = 0; i < num; i++) {
             Worker worker = new Worker();
             workers.add(worker);
             Thread thread = new Thread(worker);
             thread.start();
         }

         workerNum = workers.size();
     }

     // 减少工作线程，至少留1个，不能减少到0
     @Override
     public void removeWorkers(int num) {
         if(num >= workerNum || num <= 0){
             return;
         }

         for(int i =0;i<num;i++){
             Worker worker = workers.getLast();
             worker.shutDown();
         }

         workerNum = workers.size();
     }

     @Override
     public int getTaskSize() {
         return tasks.size();
     }

 }

5  新建测试类

 public class ThreadPoolTest {
     public static void main(String[] args) throws InterruptedException {
         //1 新建一个线程池
         DefaultThreadPool pool = new DefaultThreadPool();

         //2 设置线程池的大小为5
         pool.initWorkers(5);

         //3 启动线程池
         pool.start();

         //4 往任务队列里面添加任务
         for(int i = 0;i<100;i++){
             pool.excute(new PrintTask());
         }

     }
 }

在eclipse中运行，结果部分截图如下：

好了，一个线程池就这样，这只是一个小例子，提示线程池的原理

其实实现工作中，一个线程池要考虑的问题远比这个多，也更复杂。

其中比较重要的两个方面：

1 线程池开几个线程为最合适？

我们知道，线程不是开的越多越好，而要根据业务的场景，硬件的指标，带宽的大小等等

一般线程池的个数为CPU核心数的个数加1 ，google的建议。此外可能还要具体分析业务

大，中，小的业务需求，也是不一样的。

大任务：比如下载一部电影，可能要十几分钟甚至几十分钟的任务

中任务：比如下载一幅图片，有1M以上了到十几M的大小的。

小任务：比如下载的是游戏的ico，就十几K的到1M以下的。

小任务可以多开几个线程。

中任务的可以保守点。

大任务的尽量不要开的线程太多

具体值还需要看具体业务，具体场景。这些只是建议。

2 线程用哪种队列，也是和上面有关系。

今天就到这了，后续还会抽时间研究线程并发这块，希望对大家有帮忙。