线程池原理与使用

线程池

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

组成部分

服务器程序利用线程技术响应客户请求已经司空见惯,可能您认为这样做效率已经很高，但您有没有想过优化一下使用线程的方法。该文章将向您介绍服务器程序如何利用线程池来优化性能并提供一个简单的线程池实现。

1、线程池管理器（ThreadPoolManager）:用于创建并管理线程池

2、工作线程（WorkThread）: 线程池中线程

3、任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。

4、任务队列:用于存放没有处理的任务。提供一种缓冲机制。

技术背景

在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用已有对象来服务就是一个需要解决的关键问题，其实这就是一些"池化资源"技术产生的原因。比如大家所熟悉的数据库连接池正是遵循这一思想而产生的，本文将介绍的线程池技术同样符合这一思想。

功能

应用程序可以有多个线程，这些线程在 休眠状态中需要耗费大量时间来等待事件发生。其他 线程可能进入睡眠状态，并且仅定期被唤醒以轮循更改或更新状态信息，然后再次进入休眠状态。为了简化对这些线程的管理，.NET框架为每个进程提供了一个线程池，一个线程池有若干个等待操作状态，当一个等待操作完成时，线程池中的 辅助线程会执行 回调函数。线程池中的线程由系统管理，程序员不需要费力于线程管理，可以集中精力处理应用程序任务。

应用范围

1、需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

2、对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。

3、接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，并出现"OutOfMemory"的错误。

线程池代码示例

1. /** 
2.  * 线程池类，线程管理器：创建线程，执行任务，销毁线程，获取线程基本信息 
3.  */  
4. public final class ThreadPool {  
5.     // 线程池中默认线程的个数为5  
6.     private static int worker_num = 5;  
7.     // 工作线程  
8.     private WorkThread[] workThrads;  
9.     // 未处理的任务  
10.     private static volatile int finished_task = 0;  
11.     // 任务队列，作为一个缓冲,List线程不安全  
12.     private List<Runnable> taskQueue = new LinkedList<Runnable>();  
13.     private static ThreadPool threadPool;  
14.   
15.     // 创建具有默认线程个数的线程池  
16.     private ThreadPool() {  
17.         this(5);  
18.     }  
19.   
20.     // 创建线程池,worker_num为线程池中工作线程的个数  
21.     private ThreadPool(int worker_num) {  
22.         ThreadPool.worker_num = worker_num;  
23.         workThrads = new WorkThread[worker_num];  
24.         for (int i = 0; i < worker_num; i++) {  
25.             workThrads[i] = new WorkThread();  
26.             workThrads[i].start();// 开启线程池中的线程  
27.         }  
28.     }  
29.   
30.     // 单态模式，获得一个默认线程个数的线程池  
31.     public static ThreadPool getThreadPool() {  
32.         return getThreadPool(ThreadPool.worker_num);  
33.     }  
34.   
35.     // 单态模式，获得一个指定线程个数的线程池,worker_num(>0)为线程池中工作线程的个数  
36.     // worker_num<=0创建默认的工作线程个数  
37.     public static ThreadPool getThreadPool(int worker_num1) {  
38.         if (worker_num1 <= 0)  
39.             worker_num1 = ThreadPool.worker_num;  
40.         if (threadPool == null)  
41.             threadPool = new ThreadPool(worker_num1);  
42.         return threadPool;  
43.     }  
44.   
45.     // 执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
46.     public void execute(Runnable task) {  
47.         synchronized (taskQueue) {  
48.             taskQueue.add(task);  
49.             taskQueue.notify();  
50.         }  
51.     }  
52.   
53.     // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
54.     public void execute(Runnable[] task) {  
55.         synchronized (taskQueue) {  
56.             for (Runnable t : task)  
57.                 taskQueue.add(t);  
58.             taskQueue.notify();  
59.         }  
60.     }  
61.   
62.     // 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定  
63.     public void execute(List<Runnable> task) {  
64.         synchronized (taskQueue) {  
65.             for (Runnable t : task)  
66.                 taskQueue.add(t);  
67.             taskQueue.notify();  
68.         }  
69.     }  
70.   
71.     // 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁  
72.     public void destroy() {  
73.         while (!taskQueue.isEmpty()) {// 如果还有任务没执行完成，就先睡会吧  
74.             try {  
75.                 Thread.sleep(10);  
76.             } catch (InterruptedException e) {  
77.                 e.printStackTrace();  
78.             }  
79.         }  
80.         // 工作线程停止工作，且置为null  
81.         for (int i = 0; i < worker_num; i++) {  
82.             workThrads[i].stopWorker();  
83.             workThrads[i] = null;  
84.         }  
85.         threadPool=null;  
86.         taskQueue.clear();// 清空任务队列  
87.     }  
88.   
89.     // 返回工作线程的个数  
90.     public int getWorkThreadNumber() {  
91.         return worker_num;  
92.     }  
93.   
94.     // 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成  
95.     public int getFinishedTasknumber() {  
96.         return finished_task;  
97.     }  
98.   
99.     // 返回任务队列的长度，即还没处理的任务个数  
100.     public int getWaitTasknumber() {  
101.         return taskQueue.size();  
102.     }  
103.   
104.     // 覆盖toString方法，返回线程池信息：工作线程个数和已完成任务个数  
105.     @Override  
106.     public String toString() {  
107.         return "WorkThread number:" + worker_num + "  finished task number:"  
108.                 + finished_task + "  wait task number:" + getWaitTasknumber();  
109.     }  
110.   
111.     /** 
112.      * 内部类，工作线程 
113.      */  
114.     private class WorkThread extends Thread {  
115.         // 该工作线程是否有效，用于结束该工作线程  
116.         private boolean isRunning = true;  
117.   
118.         /* 
119.          * 关键所在啊，如果任务队列不空，则取出任务执行，若任务队列空，则等待 
120.          */  
121.         @Override  
122.         public void run() {  
123.             Runnable r = null;  
124.             while (isRunning) {// 注意，若线程无效则自然结束run方法，该线程就没用了  
125.                 synchronized (taskQueue) {  
126.                     while (isRunning && taskQueue.isEmpty()) {// 队列为空  
127.                         try {  
128.                             taskQueue.wait(20);  
129.                         } catch (InterruptedException e) {  
130.                             e.printStackTrace();  
131.                         }  
132.                     }  
133.                     if (!taskQueue.isEmpty())  
134.                         r = taskQueue.remove(0);// 取出任务  
135.                 }  
136.                 if (r != null) {  
137.                     r.run();// 执行任务  
138.                 }  
139.                 finished_task++;  
140.                 r = null;  
141.             }  
142.         }  
143.   
144.         // 停止工作，让该线程自然执行完run方法，自然结束  
145.         public void stopWorker() {  
146.             isRunning = false;  
147.         }  
148.     }  
149. } 
     

//测试线程池 

• 1. public class TestThreadPool {  
  2.     public static void main(String[] args) {  
  3.         // 创建3个线程的线程池  
  4.         ThreadPool t = ThreadPool.getThreadPool(3);  
  5.         t.execute(new Runnable[] { new Task(), new Task(), new Task() });  
  6.         t.execute(new Runnable[] { new Task(), new Task(), new Task() });  
  7.         System.out.println(t);  
  8.         t.destroy();// 所有线程都执行完成才destory  
  9.         System.out.println(t);  
  10.     }  
  11.   
  12.     // 任务类  
  13.     static class Task implements Runnable {  
  14.         private static volatile int i = 1;  
  15.   
  16.         @Override  
  17.         public void run() {// 执行任务  
  18.             System.out.println("任务 " + (i++) + " 完成");  
  19.         }  
  20.     }  
  21. }