Java多线程----Java 线程池的原理与实现

Java中的多线程是一种抢占式的机制而不是分时机制。线程主要有以下几种状态：可运行，运行，阻塞，死亡。 抢占式机制指的是有多个线程处于可运行状态，但是只有一个线程在运行。

1、wait和sleep比较：

1.1. 共同点

     1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。

     2. wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。
         如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
         需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException。

1.2. 不同点

     1. Thread类的方法：sleep(),yield()等
         Object的方法：wait()和notify()等
   
     2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
         sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

     3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

     4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常 

2. 线程池

     多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
    
     假设一个服务器完成一项任务所需时间为：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而在处理请求时浪费时间，从而提高效率。

[java]  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. }  
213.   
214. /** 任务接口类 **/  
215.   
216. package org.ymcn.util;  
217.   
218. import java.util.Date;  
219.   
220. /** 
221. * 所有任务接口 
222. * 其他任务必须继承访类 
223. *  
224. * @author obullxl 
225. */  
226. public abstract class Task implements Runnable {  
227.     // private static Logger logger = Logger.getLogger(Task.class);  
228.     /* 产生时间 */  
229.     private Date generateTime = null;  
230.     /* 提交执行时间 */  
231.     private Date submitTime = null;  
232.     /* 开始执行时间 */  
233.     private Date beginExceuteTime = null;  
234.     /* 执行完成时间 */  
235.     private Date finishTime = null;  
236.   
237.     private long taskId;  
238.   
239.     public Task() {  
240.         this.generateTime = new Date();  
241.     }  
242.   
243.     /** 
244.     * 任务执行入口 
245.     */  
246.     public void run() {  
247.         /** 
248.         * 相关执行代码 
249.         *  
250.         * beginTransaction(); 
251.         *  
252.         * 执行过程中可能产生新的任务 subtask = taskCore(); 
253.         *  
254.         * commitTransaction(); 
255.         *  
256.         * 增加新产生的任务 ThreadPool.getInstance().batchAddTask(taskCore()); 
257.         */  
258.     }  
259.   
260.     /** 
261.     * 所有任务的核心 所以特别的业务逻辑执行之处 
262.     *  
263.     * @throws Exception 
264.     */  
265.     public abstract Task[] taskCore() throws Exception;  
266.   
267.     /** 
268.     * 是否用到数据库 
269.     *  
270.     * @return 
271.     */  
272.     protected abstract boolean useDb();  
273.   
274.     /** 
275.     * 是否需要立即执行 
276.     *  
277.     * @return 
278.     */  
279.     protected abstract boolean needExecuteImmediate();  
280.   
281.     /** 
282.     * 任务信息 
283.     *  
284.     * @return String 
285.     */  
286.     public abstract String info();  
287.   
288.     public Date getGenerateTime() {  
289.         return generateTime;  
290.     }  
291.   
292.     public Date getBeginExceuteTime() {  
293.         return beginExceuteTime;  
294.     }  
295.   
296.     public void setBeginExceuteTime(Date beginExceuteTime) {  
297.         this.beginExceuteTime = beginExceuteTime;  
298.     }  
299.   
300.     public Date getFinishTime() {  
301.         return finishTime;  
302.     }  
303.   
304.     public void setFinishTime(Date finishTime) {  
305.         this.finishTime = finishTime;  
306.     }  
307.   
308.     public Date getSubmitTime() {  
309.         return submitTime;  
310.     }  
311.   
312.     public void setSubmitTime(Date submitTime) {  
313.         this.submitTime = submitTime;  
314.     }  
315.   
316.     public long getTaskId() {  
317.         return taskId;  
318.     }  
319.   
320.     public void setTaskId(long taskId) {  
321.         this.taskId = taskId;  
322.     }  
323.   
324. }