java多线程线程池的原理与实现

简单介绍 

    创建线程有两种方式：继承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而在处理请求时浪费时间，从而提高效率。 

--------------------------------------------------------------------------------- 

Java代码  

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. }   

Java代码  

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. }