java 线程池实例

 假如创建线程的时间开销为T1，线程执行任务的时间为T2，销毁线程的时间为T3，如果T1+T3 >> T2, 这个时候使用线程池往往能大大的提高性能.下面是个线程池的实例.

1. 任务接口Task

1. /*
   
2.  * To change this template, choose Tools | Templates
   
3.  * and open the template in the editor.
   
4.  */
   
5. package main;
   
6. 
   
7. /**
   
8.  *
   
9.  * @author fuzuotao
   
10.  */
    
11. /* 所有任务的接口 */
    
12.   public abstract class Task implements Runnable {
    
13.         public long _taskID = 0;
    
14.         public Task(){
    
15.             
    
16.         }
    
17.         
    
18.         public Task(long task_id){
    
19.             _taskID = task_id;
    
20.         }
    
21.         
    
22.         public void setTaskId(long task_id){
    
23.             _taskID = task_id;
    
24.         }
    
25.         
    
26.         public long getTaskId(){
    
27.             return _taskID;
    
28.         }
    
29.         
    
30.         public void run(){
    
31.             System.out.printf("test\r\n");
    
32.         }
    
33.  }

2. 线程池ThreadPool

1. /*
   
2.  * To change this template, choose Tools | Templates
   
3.  * and open the template in the editor.
   
4.  */
   
5. package main;
   
6. 
   
7. import java.util.LinkedList;
   
8. import java.util.List;
   
9. import java.util.Collections;
   
10. import org.apache.log4j.Logger;
    
11. 
    
12. /**
    
13.  *
    
14.  * @author fuzuotao
    
15.  */
    
16. public class ThreadPool{
    
17.     public static long _next_task_id = 0;
    
18.     public static final int DEFAULT_THREAD_NUM = 0xa;
    
19.     public static final int MAX_THREAD_NUM = 200;
    
20.     public int _cur_thread_num = 0;
    
21.     public boolean _is_closed = true;
    
22.     public List<Task> taskQueue = Collections.synchronizedList(new LinkedList<Task>());
    
23.     public WorkThread[] threads;
    
24.     
    
25.     public static ThreadPool _instance = null;
    
26.     
    
27.     static Logger logger = Logger.getLogger(ThreadPool.class);
    
28.     
    
29.     public ThreadPool(){
    
30.         _cur_thread_num = DEFAULT_THREAD_NUM;
    
31.         threads = new WorkThread[_cur_thread_num];
    
32.         for(int i = 0; i < _cur_thread_num; ++ i){
    
33.             threads[i] = new WorkThread(i);
    
34.         }
    
35.     }
    
36.     
    
37.     public ThreadPool(int thread_num){
    
38.         _cur_thread_num = thread_num;
    
39.         threads = new WorkThread[_cur_thread_num];
    
40.         for(int i = 0; i < _cur_thread_num; ++ i){
    
41.             threads[i] = new WorkThread(i); 
    
42.         }
    
43.     }
    
44.     
    
45.     /* singleton */
    
46.     public static ThreadPool getInstance(){
    
47.         if(_instance == null){
    
48.             synchronized(ThreadPool.class){
    
49.                 if(_instance == null){
    
50.                     _instance = new ThreadPool();
    
51.                 }
    
52.             }
    
53.         }
    
54.         return _instance;
    
55.     }
    
56.     
    
57.     public static long generateTaskId(){
    
58.         _next_task_id += (_next_task_id + 1) / 1000000;
    
59.         if(_next_task_id == 0) _next_task_id ++;
    
60.         return _next_task_id;
    
61.     }
    
62.     
    
63.     public void start(){
    
64.         _is_closed = false;
    
65.         for(int i = 0; i < _cur_thread_num; ++ i){
    
66.             threads[i].start();
    
67.             logger.info(String.format("thread [%d] start!", i));
    
68.         }
    
69.     }
    
70.     
    
71.     public void close(){
    
72.         if(!_is_closed){
    
73.             waitforfinish();
    
74.             _is_closed = true;
    
75.             taskQueue.clear();
    
76.         }
    
77.         logger.info("Thread pool close!");
    
78.     }
    
79.     
    
80.     public void waitforfinish(){
    
81.         synchronized(this){
    
82.             _is_closed = true;
    
83.             notifyAll();
    
84.         }
    
85.         for(int i = 0; i < _cur_thread_num; ++ i){
    
86.             threads[i].stopThread();
    
87.             logger.info(String.format("Thread [%d] stop!", i));
    
88.         }
    
89.     }
    
90.    
    
91.     public void addTask(Task new_task){
    
92.         if(_is_closed){
    
93.             throw new IllegalStateException();
    
94.         }
    
95.         synchronized(taskQueue){
    
96.             if(new_task != null){
    
97.                 taskQueue.add(new_task);
    
98.                 taskQueue.notifyAll();
    
99.                 //taskQueue.notify();
    
100. 
     
101.             }
     
102.         }
     
103.     }
     
104.     
     
105.     public int getTaskCount(){
     
106.         return taskQueue.size();
     
107.     }
     
108.     
     
109.     public class WorkThread extends Thread{
     
110.         private int _index;
     
111.         private boolean _is_running = true;
     
112.         public WorkThread(int index){
     
113.             _index = index;
     
114.         }
     
115.         
     
116.         public void run(){
     
117.             while(_is_running){
     
118.                 Task t = getTask();
     
119.                 if(t != null){
     
120.                     t.run();
     
121.                 }else{
     
122.                     // 结束线程
     
123. 
     
124.                     logger.info(String.format("thread [%d] exit", _index));
     
125.                     return;
     
126.                 }
     
127.             }
     
128.         }
     
129.         
     
130.         public Task getTask(){
     
131.             if(_is_closed) return null;
     
132.             Task r = null;
     
133.             synchronized (taskQueue) {
     
134.                 while (taskQueue.isEmpty()) {
     
135.                     try {
     
136.                         /* 任务队列为空，则等待有新任务加入从而被唤醒 */
     
137.                         taskQueue.wait();
     
138.                     } catch (InterruptedException ie) {
     
139.                         logger.error(PrintStackTrace.getStackTrace(ie));
     
140.                     }
     
141.                 }
     
142.                 
     
143.                 /* 取出任务执行 */
     
144.                 r = (Task) taskQueue.remove(0);
     
145.                 return r;
     
146.             }
     
147.         }
     
148.         
     
149.         public void stopThread(){
     
150.             _is_running = false;
     
151.             try{
     
152.                 join();
     
153.             }catch(InterruptedException ex){
     
154.                 logger.error(PrintStackTrace.getStackTrace(ex));
     
155.             }
     
156.         }
     
157.     }
     
158.     
     
159. }

在实际使用过程中继承Task抽象类，并重写run()方法即可