JAVA服务器端Socket线程池

1. import java.util.Vector;
2. import java.net.*;
3. import java.io.*;
4. 
   
5. 
   
6. public class ThreadPool {
7.     public static final int MAX_THREADS = 100;
8.     public static final int MAX_SPARE_THREADS = 50;
9.     public static final int MIN_SPARE_THREADS = 10;
10.     public static final int WORK_WAIT_TIMEOUT = 60 * 1000;
11. 
    
12.     protected Vector pool; //存放空闲线程
13.     protected MonitorRunnable monitor; //A monitor thread that monitors the pool for idel threads.
14.     protected int maxThreads; //Max number of threads that you can open in the pool.
15.     protected int minSpareThreads; //Min number of idel threads that you can leave in the pool.
16.     protected int maxSpareThreads; //Max number of idel threads that you can leave in the pool.
17.     protected int currentThreadCount; //Number of threads in the pool.
18.     protected int currentThreadsBusy; //Number of busy threads in the pool.
19.     protected boolean stopThePool; //Flag that the pool should terminate all the threads and stop.
20. 
    
21.     /**
22.      * Construct
23.      */
24.     public ThreadPool() {
25.       maxThreads = MAX_THREADS;
26.       maxSpareThreads = MAX_SPARE_THREADS;
27.       minSpareThreads = MIN_SPARE_THREADS;
28.       currentThreadCount = 0;
29.       currentThreadsBusy = 0;
30.       stopThePool = false;
31.     }
32. 
    
33.     /**
34.      * 启动线程池
35.      */
36.     public synchronized void start() {
37.       adjustLimits(); //调整最大和最小线程数及最大和最小多余线程数.
38.       openThreads(minSpareThreads); //打开初始线程
39.       monitor = new MonitorRunnable(this); //Runnable对象实例     //A monitor thread that monitors the pool for idel threads.
40.     }
41. 
    
42.     public void setMaxThreads(int maxThreads) {
43.       this.maxThreads = maxThreads;
44.     }
45. 
    
46.     public int getMaxThreads() {
47.       return maxThreads;
48.     }
49. 
    
50.     public void setMinSpareThreads(int minSpareThreads) {
51.       this.minSpareThreads = minSpareThreads;
52.     }
53. 
    
54.     public int getMinSpareThreads() {
55.       return minSpareThreads;
56.     }
57. 
    
58.     public void setMaxSpareThreads(int maxSpareThreads) {
59.       this.maxSpareThreads = maxSpareThreads;
60.     }
61. 
    
62.     public int getMaxSpareThreads() {
63.       return maxSpareThreads;
64.     }
65. 
    
66.     /**
67.      * 线程池管理方法.
68.      * 当空闲队列线程中没有空闲线程时,则增加处理(空闲)线程数量.
69.      * 如果线程数量已达到最大线程数,则新的连接进行等待.
70.      * 当请求到来,且有空闲线程时调用处理线程进行具体业务处理.
71.      * @param r ThreadPoolRunnable
72.      */
73.     public void runIt(Socket cs) { //r 为task      //有任务进入时调用
74.       if (null == cs) {
75.         throw new NullPointerException();
76.       }
77.       if (0 == currentThreadCount || stopThePool) {
78.         throw new IllegalStateException();
79.       }
80.       ControlRunnable c = null; //任务处理实例.
81.       synchronized (this) {
82.         if (currentThreadsBusy == currentThreadCount) { //如果工作线程和当前线程数相等,说明没有空闲线程.
83.           if (currentThreadCount < maxThreads) { //如果当前线程数还没有达到最大线程数.
84.             int toOpen = currentThreadCount + minSpareThreads; //再增加minSpareThreads个线程量.
85.             openThreads(toOpen); //打开线程新增空闲线程.    //currentThreadCount数量增加
86.           }
87.           else { //如果当前数量达到了最大线程数.
88.             while (currentThreadsBusy == currentThreadCount) { //当工作线程和当前线程数相等,说明没有空闲线程.
89.               try {
90.                 this.wait(); //连接线程进行等待.
91.               }
92.               catch (InterruptedException e) {
93.               }
94.               if (0 == currentThreadCount || stopThePool) {
95.                 throw new IllegalStateException();
96.               }
97.             }
98.           }
99.         }
100.         c = (ControlRunnable) pool.lastElement(); //在有空闲线程的情况下,从空闲线程队列中取出最后一个线程.
101.         pool.removeElement(c); //从空闲队列中删除最后一个线程,用于处理其他事件.
102.         currentThreadsBusy++; //对处理事件的线程数加1
103.       }
104.       System.out.println("系统调用一个Sokcet线程");
105.       c.runIt(cs); //调用具体业务方法,告诉其有数据请求要处理,唤醒等待中的线程.
106.     }
107. 
     
108.     /**
109.      * 关闭线程池
110.      */
111.     public synchronized void shutdown() {
112.       if (!stopThePool) { //如果线程池没有关闭,(线程池关闭标识为假)
113.         stopThePool = true;
114.         monitor.terminate(); //关闭监视线程
115.         monitor = null;
116.         for (int i = 0; i < (currentThreadCount - currentThreadsBusy); i++) { //关闭空闲线程队列
117.           try {
118.             ( (ControlRunnable) (pool.elementAt(i))).terminate();
119.           }
120.           catch (Throwable t) {
121.           }
122.         }
123.         currentThreadsBusy = currentThreadCount = 0;
124.         pool = null;
125.         notifyAll(); //唤醒所有在等待的线程.
126.       }
127.     }
128. 
     
129.     /**
130.      * 当线程大于最大多余线程时关闭多余的线程.
131.      */
132.     protected synchronized void checkSpareControllers() {
133.       if (stopThePool) { //如果连接池没有关闭.
134.         return;
135.       }
136. 
     
137.       if ( (currentThreadCount - currentThreadsBusy) > maxSpareThreads) { //如果空闲的线程数大于多余的最大线程数量.
138.         int toFree = currentThreadCount - currentThreadsBusy - maxSpareThreads; //得出多余的线程数量
139.         for (int i = 0; i < toFree; i++) { //关闭删除空闲线程,从Vector中删除
140.           ControlRunnable c = (ControlRunnable) pool.firstElement();
141.           pool.removeElement(c);
142.           c.terminate(); //让删除的线程结束
143.           currentThreadCount--; //处理线程队列减少一个
144.         }
145.       }
146.     }
147. 
     
148.     /**
149.      * 当线程处理完成后重新放到空闲线程队列中.
150.      * @param c ControlRunnable
151.      */
152.     protected synchronized void returnController(ControlRunnable c) {
153.       if (0 == currentThreadCount || stopThePool) { //如果线程池关闭或当前连接线程数量为0
154.         c.terminate(); //关闭当前线程.
155.         return;
156.       }
157.       currentThreadsBusy--; //处理线程队列的数量减少一个
158.       pool.addElement(c); //空闲线程队列中增加一个
159.       notifyAll(); //唤醒可能在等待连接的线程.
160.     }
161. 
     
162.     /**
163.      * 当一个处理线程出现异常时,要重新开启一个空闭线程.,并唤醒在等待空闲线程的线程.ThreadPool的runIt中等待的线程.
164.      */
165.     protected synchronized void notifyThreadEnd() {
166.       currentThreadsBusy--; //因从线程是在处理数据时出现异常,所处理线程队列的数量要减一个.
167.       currentThreadCount--; //因出现异常的线程关闭了.所开户线程的数量要减少一个.
168.       notifyAll(); //唤醒等待连接的阻塞线程.
169.       openThreads(minSpareThreads); //重新打开minSpareThreads个线程.如currentThreadCount的数量大于minSpareThreads,则还是不开启新线程.
170.     }
171. 
     
172.     /**
173.      * 调整各种线程队列数量
174.      */
175.     protected void adjustLimits() {
176.       if (maxThreads <= 0) { //如果最大线程数小于0
177.         maxThreads = MAX_THREADS; //设置最大线程数为100
178.       }
179.       if (maxSpareThreads >= maxThreads) { //如果最大多余线程数大于最大线程数.
180.         maxSpareThreads = maxThreads; //设置最大多余线程数为最大线程数.
181.       }
182.       if (maxSpareThreads <= 0) { //如果最大多余线程数小于0
183.         if (1 == maxThreads) {
184.           maxSpareThreads = 1; //如最大线程数为1的情况下,设置最大多余线程数为1.
185.         }
186.         else {
187.           maxSpareThreads = maxThreads / 2; //设置最大多余线程数为最大线程数的一半.
188.         }
189.       }
190.       if (minSpareThreads > maxSpareThreads) { //如果最小多余线程大于最大多余线程数
191.         minSpareThreads = maxSpareThreads; //设置最小多余线程数为最大多余线程数.
192.       }
193.       if (minSpareThreads <= 0) { //如果最小多余线程数小于0
194.         if (1 == maxSpareThreads) {
195.           minSpareThreads = 1; //如最大线程数为1的情况下,则设置最小多余线程数为1.
196.         }
197.         else {
198.           minSpareThreads = maxSpareThreads / 2; //否则设置最小多余线程数为最大多余线程数的一半.
199.         }
200.       }
201.     }
202. 
     
203.     /**
204.      * 打开指定数量的空闲线程队列
205.      * @param toOpen int
206.      */
207.     protected void openThreads(int toOpen) { //toOpen=minSpareThreads
208.       if (toOpen > maxThreads) {
209.         toOpen = maxThreads;
210.       }
211.       if (0 == currentThreadCount) { //如果当前线程池中的线程数量为0
212.         pool = new Vector(toOpen); //创建一个有minSpareThreads数量的Vector
213.       }
214.       //因第二次增加时对第一次增加的线程不能重复增加.所要从currentThreadCount开始.
215.       for (int i = currentThreadCount; i < toOpen; i++) { //先增加minSparethreads数量的线程.
216.         pool.addElement(new ControlRunnable(this)); //Runnable实例对象,可用于创建线程
217.       }
218.       currentThreadCount = toOpen;
219.     }
220. 
     
221.     /**
222.      * 监视线程,用于监听当前空闲线程是否大于最大多余线程数量,如存在则关闭多余的空闲线程.
223.      */
224.     class MonitorRunnable
225.         implements Runnable {
226.       ThreadPool p;
227.       Thread t;
228.       boolean shouldTerminate;
229. 
     
230.       /**
231.        * construct
232.        * @param p ThreadPool
233.        */
234.       MonitorRunnable(ThreadPool p) {
235.         shouldTerminate = false;
236.         this.p = p;
237.         t = new Thread(this);
238.         t.start();
239.       }
240. 
     
241.       public void run() {
242.         while (true) {
243.           try {
244.             synchronized (this) {
245.               this.wait(WORK_WAIT_TIMEOUT);
246.             }
247.             if (shouldTerminate) { //如果结束
248.               break;
249.             }
250.             p.checkSpareControllers(); //检查是否有多余线程.
251.           }
252.           catch (Throwable t) {
253.             t.printStackTrace();
254.           }
255.         }
256.       }
257. 
     
258.       public void stop() {
259.         this.terminate();
260.       }
261. 
     
262.       public synchronized void terminate() {
263.         shouldTerminate = true;
264.         this.notifyAll();
265.       }
266.     }
267. }