Java 线程池的原理与实现

这几天主要是狂看源程序，在弥补了一些以前知识空白的同时，也学会了不少新的知识（比如 NIO），或者称为新技术吧。
线程池就是其中之一，一提到线程，我们会想到以前《操作系统》的生产者与消费者，信号量，同步控制等等。
一提到池，我们会想到数据库连接池，但是线程池又如何呢？

建议：在阅读本文前，先理一理同步的知识，特别是syncronized同步关键字的用法。
关于我对同步的认识，要缘于大三年的一本书，书名好像是 Java 实战，这本书写得实在太妙了，真正的从理论到实践，从截图分析到.class字节码分析。哇，我想市场上很难买到这么精致的书了。
我对此书印象最深之一的就是：equal()方法，由浅入深，经典！
还有就是同步了，其中提到了我的几个编程误区，以前如何使用同步提高性能等等，通过学习，使我对同步的认识进一步加深。
--------------------------------------------------------------------------------------------------
简单介绍

    创建线程有两种方式：继承Thread或实现Runnable。Thread实现了Runnable接口，提供了一个空的run()方法，所以不论是继承Thread还是实现Runnable，都要有自己的run()方法。
    一个线程创建后就存在，调用start()方法就开始运行（执行run()方法），调用wait进入等待或调用sleep进入休眠期，顺利运行完毕或休眠被中断或运行过程中出现异常而退出。

wait和sleep比较：
      sleep方法有：sleep(long millis)，sleep(long millis, long nanos)，调用sleep方法后，当前线程进入休眠期，暂停执行，但该线程继续拥有监          视资源的所有权。到达休眠时间后线程将继续执行，直到完成。若在休眠期另一线程中断该线程，则该线程退出。
      wait方法有：wait()，wait(long timeout)，wait(long timeout, long nanos)，调用wait方法后，该线程放弃监视资源的所有权进入等待状态；
       wait()：等待有其它的线程调用notify()或notifyAll()进入调度状态，与其它线程共同争夺监视。wait()相当于wait(0)，wait(0, 0)。
      wait(long timeout)：当其它线程调用notify()或notifyAll()，或时间到达timeout亳秒，或有其它某线程中断该线程，则该线程进入调度状态。
      wait(long timeout, long nanos)：相当于wait(1000000*timeout + nanos)，只不过时间单位为纳秒。
===================================================================================================

线程池：
    多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
    
    假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
    
    如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。

                

     一个线程池包括以下四个基本组成部分：

                1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
                2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
                3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工                        作，任务的执行状态等；
                4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
                

    线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段

    或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

    线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：

    假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。
------------------------------------------------------------------------------

好了，废话就到这里了，下面就是程序了，我也不讲解了，注释已经很清晰了：

线程池管理器ThreadPool.Java

[cpp] view plain copy

1. /** 线程池类，工作线程作为其内部类 **/  
2.   
3. package org.ymcn.util;  
4.   
5. import java.util.Collections;  
6. import java.util.Date;  
7. import java.util.LinkedList;  
8. import java.util.List;  
9.   
10. import org.apache.log4j.Logger;  
11.   
12. /** 
13. * 线程池 
14. * 创建线程池，销毁线程池，添加新任务 
15. *  
16. * @author obullxl 
17. */  
18. public final class ThreadPool {  
19.     private static Logger logger = Logger.getLogger(ThreadPool.class);  
20.     private static Logger taskLogger = Logger.getLogger("TaskLogger");  
21.   
22.     private static boolean debug = taskLogger.isDebugEnabled();  
23.     // private static boolean debug = taskLogger.isInfoEnabled();  
24.     /* 单例 */  
25.     private static ThreadPool instance = ThreadPool.getInstance();  
26.   
27.     public static final int SYSTEM_BUSY_TASK_COUNT = 150;  
28.     /* 默认池中线程数 */  
29.     public static int worker_num = 5;  
30.     /* 已经处理的任务数 */  
31.     private static int taskCounter = 0;  
32.   
33.     public static boolean systemIsBusy = false;  
34.   
35.     private static List<Task> taskQueue = Collections  
36.             .synchronizedList(new LinkedList<Task>());  
37.     /* 池中的所有线程 */  
38.     public PoolWorker[] workers;  
39.   
40.     private ThreadPool() {  
41.         workers = new PoolWorker[5];  
42.         for (int i = 0; i < workers.length; i++) {  
43.             workers[i] = new PoolWorker(i);  
44.         }  
45.     }  
46.   
47.     private ThreadPool(int pool_worker_num) {  
48.         worker_num = pool_worker_num;  
49.         workers = new PoolWorker[worker_num];  
50.         for (int i = 0; i < workers.length; i++) {  
51.             workers[i] = new PoolWorker(i);  
52.         }  
53.     }  
54.   
55.     public static synchronized ThreadPool getInstance() {  
56.         if (instance == null)  
57.             return new ThreadPool();  
58.         return instance;  
59.     }  
60.     /** 
61.     * 增加新的任务 
62.     * 每增加一个新任务，都要唤醒任务队列 
63.     * @param newTask 
64.     */  
65.     public void addTask(Task newTask) {  
66.         synchronized (taskQueue) {  
67.             newTask.setTaskId(++taskCounter);  
68.             newTask.setSubmitTime(new Date());  
69.             taskQueue.add(newTask);  
70.             /* 唤醒队列, 开始执行 */  
71.             taskQueue.notifyAll();  
72.         }  
73.         logger.info("Submit Task<" + newTask.getTaskId() + ">: "  
74.                 + newTask.info());  
75.     }  
76.     /** 
77.     * 批量增加新任务 
78.     * @param taskes 
79.     */  
80.     public void batchAddTask(Task[] taskes) {  
81.         if (taskes == null || taskes.length == 0) {  
82.             return;  
83.         }  
84.         synchronized (taskQueue) {  
85.             for (int i = 0; i < taskes.length; i++) {  
86.                 if (taskes[i] == null) {  
87.                     continue;  
88.                 }  
89.                 taskes[i].setTaskId(++taskCounter);  
90.                 taskes[i].setSubmitTime(new Date());  
91.                 taskQueue.add(taskes[i]);  
92.             }  
93.             /* 唤醒队列, 开始执行 */  
94.             taskQueue.notifyAll();  
95.         }  
96.         for (int i = 0; i < taskes.length; i++) {  
97.             if (taskes[i] == null) {  
98.                 continue;  
99.             }  
100.             logger.info("Submit Task<" + taskes[i].getTaskId() + ">: "  
101.                     + taskes[i].info());  
102.         }  
103.     }  
104.     /** 
105.     * 线程池信息 
106.     * @return 
107.     */  
108.     public String getInfo() {  
109.         StringBuffer sb = new StringBuffer();  
110.         sb.append("\nTask Queue Size:" + taskQueue.size());  
111.         for (int i = 0; i < workers.length; i++) {  
112.             sb.append("\nWorker " + i + " is "  
113.                     + ((workers[i].isWaiting()) ? "Waiting." : "Running."));  
114.         }  
115.         return sb.toString();  
116.     }  
117.     /** 
118.     * 销毁线程池 
119.     */  
120.     public synchronized void destroy() {  
121.         for (int i = 0; i < worker_num; i++) {  
122.             workers[i].stopWorker();  
123.             workers[i] = null;  
124.         }  
125.         taskQueue.clear();  
126.     }  
127.   
128.     /** 
129.     * 池中工作线程 
130.     *  
131.     * @author obullxl 
132.     */  
133.     private class PoolWorker extends Thread {  
134.         private int index = -1;  
135.         /* 该工作线程是否有效 */  
136.         private boolean isRunning = true;  
137.         /* 该工作线程是否可以执行新任务 */  
138.         private boolean isWaiting = true;  
139.   
140.         public PoolWorker(int index) {  
141.             this.index = index;  
142.             start();  
143.         }  
144.   
145.         public void stopWorker() {  
146.             this.isRunning = false;  
147.         }  
148.   
149.         public boolean isWaiting() {  
150.             return this.isWaiting;  
151.         }  
152.         /** 
153.         * 循环执行任务 
154.         * 这也许是线程池的关键所在 
155.         */  
156.         public void run() {  
157.             while (isRunning) {  
158.                 Task r = null;  
159.                 synchronized (taskQueue) {  
160.                     while (taskQueue.isEmpty()) {  
161.                         try {  
162.                             /* 任务队列为空，则等待有新任务加入从而被唤醒 */  
163.                             taskQueue.wait(20);  
164.                         } catch (InterruptedException ie) {  
165.                             logger.error(ie);  
166.                         }  
167.                     }  
168.                     /* 取出任务执行 */  
169.                     r = (Task) taskQueue.remove(0);  
170.                 }  
171.                 if (r != null) {  
172.                     isWaiting = false;  
173.                     try {  
174.                         if (debug) {  
175.                             r.setBeginExceuteTime(new Date());  
176.                             taskLogger.debug("Worker<" + index  
177.                                     + "> start execute Task<" + r.getTaskId() + ">");  
178.                             if (r.getBeginExceuteTime().getTime()  
179.                                     - r.getSubmitTime().getTime() > 1000)  
180.                                 taskLogger.debug("longer waiting time. "  
181.                                         + r.info() + ",<" + index + ">,time:"  
182.                                         + (r.getFinishTime().getTime() - r  
183.                                                 .getBeginExceuteTime().getTime()));  
184.                         }  
185.                         /* 该任务是否需要立即执行 */  
186.                         if (r.needExecuteImmediate()) {  
187.                             new Thread(r).start();  
188.                         } else {  
189.                             r.run();  
190.                         }  
191.                         if (debug) {  
192.                             r.setFinishTime(new Date());  
193.                             taskLogger.debug("Worker<" + index  
194.                                     + "> finish task<" + r.getTaskId() + ">");  
195.                             if (r.getFinishTime().getTime()  
196.                                     - r.getBeginExceuteTime().getTime() > 1000)  
197.                                 taskLogger.debug("longer execution time. "  
198.                                         + r.info() + ",<" + index + ">,time:"  
199.                                         + (r.getFinishTime().getTime() - r  
200.                                                 .getBeginExceuteTime().getTime()));  
201.                         }  
202.                     } catch (Exception e) {  
203.                         e.printStackTrace();  
204.                         logger.error(e);  
205.                     }  
206.                     isWaiting = true;  
207.                     r = null;  
208.                 }  
209.             }  
210.         }  
211.     }  
212. }  

任务接口类Task.java

[java] view plain copy

 

1. /** 任务接口类 **/  
2.   
3. package org.ymcn.util;  
4.   
5. import java.util.Date;  
6.   
7. /** 
8. * 所有任务接口 
9. * 其他任务必须继承访类 
10. *  
11. * @author obullxl 
12. */  
13. public abstract class Task implements Runnable {  
14.     // private static Logger logger = Logger.getLogger(Task.class);  
15.     /* 产生时间 */  
16.     private Date generateTime = null;  
17.     /* 提交执行时间 */  
18.     private Date submitTime = null;  
19.     /* 开始执行时间 */  
20.     private Date beginExceuteTime = null;  
21.     /* 执行完成时间 */  
22.     private Date finishTime = null;  
23.   
24.     private long taskId;  
25.   
26.     public Task() {  
27.         this.generateTime = new Date();  
28.     }  
29.   
30.     /** 
31.     * 任务执行入口 
32.     */  
33.     public void run() {  
34.         /** 
35.         * 相关执行代码 
36.         *  
37.         * beginTransaction(); 
38.         *  
39.         * 执行过程中可能产生新的任务 subtask = taskCore(); 
40.         *  
41.         * commitTransaction(); 
42.         *  
43.         * 增加新产生的任务 ThreadPool.getInstance().batchAddTask(taskCore()); 
44.         */  
45.     }  
46.   
47.     /** 
48.     * 所有任务的核心 所以特别的业务逻辑执行之处 
49.     *  
50.     * @throws Exception 
51.     */  
52.     public abstract Task[] taskCore() throws Exception;  
53.   
54.     /** 
55.     * 是否用到数据库 
56.     *  
57.     * @return 
58.     */  
59.     protected abstract boolean useDb();  
60.   
61.     /** 
62.     * 是否需要立即执行 
63.     *  
64.     * @return 
65.     */  
66.     protected abstract boolean needExecuteImmediate();  
67.   
68.     /** 
69.     * 任务信息 
70.     *  
71.     * @return String 
72.     */  
73.     public abstract String info();  
74.   
75.     public Date getGenerateTime() {  
76.         return generateTime;  
77.     }  
78.   
79.     public Date getBeginExceuteTime() {  
80.         return beginExceuteTime;  
81.     }  
82.   
83.     public void setBeginExceuteTime(Date beginExceuteTime) {  
84.         this.beginExceuteTime = beginExceuteTime;  
85.     }  
86.   
87.     public Date getFinishTime() {  
88.         return finishTime;  
89.     }  
90.   
91.     public void setFinishTime(Date finishTime) {  
92.         this.finishTime = finishTime;  
93.     }  
94.   
95.     public Date getSubmitTime() {  
96.         return submitTime;  
97.     }  
98.   
99.     public void setSubmitTime(Date submitTime) {  
100.         this.submitTime = submitTime;  
101.     }  
102.   
103.     public long getTaskId() {  
104.         return taskId;  
105.     }  
106.   
107.     public void setTaskId(long taskId) {  
108.         this.taskId = taskId;  
109.     }  
110.   
111. }