JAVA线程池实现

JAVA的线程池,准备写C#,拿来参考

1. package org.jr.util;
   
2. 
   
3. /**
   
4. * <p>Copyright: Copyright (c) 2002-2003</p>
   
5. * <p>Company: JavaResearch(http://www.javaresearch.org)</p>
   
6. * <p>最后更新日期:2003年4月22日</p>
   
7. * @author hijack
   
8. */
   
9. import java.util.Vector;
   
10. 
    
11. /**
    
12. *线程池的方法使得在线程密集的情况下原有线程得到重用
    
13. *从而提高性能
    
14. *@since 0.6
    
15. */
    
16. public class ThreadPool implements Runnable{
    
17. 
    
18.   //ThreadPool里最大线程数、最少线程数、释放延时的确省值
    
19.   public final static int DEFAULT_MIN_SIZE = 0;
    
20.   public final static int DEFAULT_MAX_SIZE = Integer.MAX_VALUE;
    
21.   public final static long DEFAULT_RELEASE_DELAY = 10 * 1000;
    
22.   //用户定制的threadpool属性值
    
23.   protected int minSize;
    
24.   protected int maxSize;
    
25.   protected long releaseDelay;
    
26.   //ThreadPool里现有的线程数
    
27.   protected int currentSize;
    
28.   //ThradPool里还可以提供的线程数
    
29.   protected int availableThreads;
    
30.   //任务列表(实质意义上的线程池)
    
31.   protected Vector taskList;
    
32. 
    
33.   /**
    
34.    *用户定制的ThradPool
    
35.    *@param minSize 线程池最少线程数
    
36.    *@param maxSize 线程池最多线程数
    
37.    *@param releaseDelay 线程释放延时
    
38.    */
    
39.   public ThreadPool(int minSize,int maxSize,long releaseDelay) {
    
40.     this.minSize = minSize;
    
41.     this.maxSize = maxSize;
    
42.     this.releaseDelay = releaseDelay;
    
43.     taskList = new Vector(100);
    
44.     availableThreads = 0;
    
45.   }
    
46.   /**
    
47.    *缺省的ThreadPool
    
48.    */
    
49.   public ThreadPool(){
    
50.     this(DEFAULT_MIN_SIZE,DEFAULT_MIN_SIZE,DEFAULT_RELEASE_DELAY);
    
51.   }
    
52.   /**
    
53.    *设置线程池中最少线程数
    
54.    *@param minSize 线程池最少线程数
    
55.    */
    
56.   public synchronized void setMinSize(int minSize){
    
57.     this.minSize = minSize;
    
58.   }
    
59.   /**
    
60.    *读取线程池最少线程数这一属性
    
61.    */
    
62.   public synchronized int getMinSize(){
    
63.     return minSize;
    
64.   }
    
65.   /**
    
66.    *设置线程池中最大线程数
    
67.    *@param maxSize 线程池最大线程数
    
68.    */
    
69.   public synchronized void setMaxSize(int maxSize){
    
70.     this.maxSize = maxSize;
    
71.   }
    
72.   /**
    
73.    *读取线程池最大线程数这一属性
    
74.    */
    
75.   public synchronized int getMaxSize(){
    
76.     return maxSize;
    
77.   }
    
78.   /**
    
79.    *设置线程池中线程释放延时
    
80.    *@param releaseDelay 线程释放延时
    
81.    */
    
82.   public synchronized void setReleaseDelay(long releaseDelay){
    
83.     this.releaseDelay = releaseDelay;
    
84.   }
    
85.   /**
    
86.    *读取线程释放延时这一属性
    
87.    */
    
88.   public synchronized long getReleaseDelay(){
    
89.     return releaseDelay;
    
90.   }
    
91.   /**
    
92.    *往ThreadPool里添加新的任务
    
93.    *@param runnable 新的任务
    
94.    */
    
95.   public synchronized void addTask(Runnable runnable){
    
96. 
    
97.     taskList.addElement(runnable);
    
98.     if(availableThreads > 0){
    
99.        this.notify();
    
100.     }
     
101.     else{
     
102.       if(currentSize < maxSize){
     
103.         Thread t = new Thread(this);
     
104.         currentSize++;
     
105.         t.start();
     
106.       }
     
107.     }
     
108.   }
     
109. 
     
110.   public void run(){
     
111.     Runnable task;
     
112.     while(true){
     
113.       synchronized(this){
     
114.         if(currentSize > maxSize){
     
115.           currentSize--;
     
116.           break;
     
117.         }
     
118.         task = getNextTask();
     
119.         if(task == null ){
     
120.           try{
     
121.             availableThreads++;
     
122.             wait(releaseDelay);
     
123.             availableThreads--;
     
124.           }catch(InterruptedException ie){
     
125.             // do something you wanna
     
126.           }
     
127.           task = getNextTask();
     
128.           if(task == null){
     
129.             if(currentSize < minSize)
     
130.               continue;
     
131.             currentSize--;
     
132.             break;
     
133.           }
     
134.         }
     
135.       }
     
136.       try{
     
137.         task.run();
     
138.       }catch(Exception e){
     
139.         System.err.println("Uncaught exception");
     
140.         e.printStackTrace(System.err);
     
141.       }
     
142.     }
     
143.   }
     
144.   /**
     
145.    *从任务列表中获取下一个任务
     
146.    *
     
147.    */
     
148.   protected synchronized Runnable getNextTask(){
     
149.     Runnable task = null;
     
150.     if(taskList.size() > 0){
     
151.       task = (Runnable)(taskList.elementAt(0));
     
152.       taskList.removeElementAt(0);
     
153.     }
     
154.     return task;
     
155.   }
     
156.   /**
     
157.    *返回ThreadPool的信息
     
158.    */
     
159.   public String toString(){
     
160.     StringBuffer sb = new StringBuffer();
     
161.     sb.append("DEFAULT_MIN_SIZE : " + DEFAULT_MIN_SIZE + "/n");
     
162.     sb.append("DEFAULT_MAX_SIZE : " + DEFAULT_MAX_SIZE + "/n");
     
163.     sb.append("DEFAULT_RELEASE_DELAY : " + DEFAULT_RELEASE_DELAY + "/n" );
     
164.     sb.append("the information about your's construct ThreadPool below : /n");
     
165.     sb.append("minSize /t maxSize /t releaseDelay /n");
     
166.     sb.append(minSize + "/t" +  maxSize +"/t" + releaseDelay );
     
167. 
     
168.     return sb.toString();
     
169.   }
     
170. 
     
171. }