线程池

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

  http://javaresearch.gro.clinux.org/source/org/jr/util/ThreadPool.java.html