为什么要用线程池

在Java中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在处理实际的用户请求的时间和资源要多得多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个JVM里创建太多的线程，可能会导致系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。

线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重用线程，线程创建的开

销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延

迟。这样，就可以立即为请求服务，使应用程序响应更快。另外，通过适当地调整线程池中的线程数目

可以防止出现资源不足的情况。

创建一个线程池

一个比较简单的线程池至少应包含线程池管理器、工作线程、任务队列、任务接口等部分。其中线程池

管理器（ThreadPool Manager）的作用是创建、销毁并管理线程池，将工作线程放入线程池中；工作

线程是一个可以循环执行任务的线程，在没有任务时进行等待；任务队列的作用是提供一种缓冲机制，

将没有处理的任务放在任务队列中；任务接口是每个任务必须实现的接口，主要用来规定任务的入口、

任务执行完后的收尾工作、任务的执行状态等，工作线程通过该接口调度任务的执行。

线程池适合应用的场合当一个Web服务器接受到大量短小线程的请求时，使用线程池技术是非常合适的，它可以大大减少线程

的创建和销毁次数，提高服务器的工作效率。但如果线程要求的运行时间比较长，此时线程的运行时间

比创建时间要长得多，单靠减少创建时间对系统效率的提高不明显，此时就不适合应用线程池技术，需

要借助其它的技术来提高服务器的服务效率。

使用线程池的风险

虽然线程池是构建多线程应用程序的强大机制，但使用它并不是没有风险的。用线程池构建的应用程序

容易遭受任何其它多线程应用程序容易遭受的所有并发风险，诸如同步错误和死锁，它还容易遭受特定

于线程池的少数其它风险，诸如与池有关的死锁、资源不足和线程泄漏。

死锁

任何多线程应用程序都有死锁风险。当一组进程或线程中的每一个都在等待一个只有该组中另一个进程

才能引起的事件时，我们就说这组进程或线程死锁了。死锁的最简单情形是：线程 A 持有对象 X 的独占

锁，并且在等待对象 Y 的锁，而线程 B 持有对象 Y 的独占锁，却在等待对象 X 的锁。除非有某种方法来

打破对锁的等待（Java 锁定不支持这种方法），否则死锁的线程将永远等下去。

虽然任何多线程程序中都有死锁的风险，但线程池却引入了另一种死锁可能，在那种情况下，所有池线

程都在执行已阻塞的等待队列中另一任务的执行结果的任务，但这一任务却因为没有未被占用的线程而

不能运行。当线程池被用来实现涉及许多交互对象的模拟，被模拟的对象可以相互发送查询，这些查询

接下来作为排队的任务执行，查询对象又同步等待着响应时，会发生这种情况。

资源不足

线程池的一个优点在于：相对于其它替代调度机制（有些我们已经讨论过）而言，它们通常执行得很

好。但只有恰当地调整了线程池大小时才是这样的。线程消耗包括内存和其它系统资源在内的大量资

源。除了 Thread 对象所需的内存之外，每个线程都需要两个可能很大的执行调用堆栈。除此以外，JVM

可能会为每个 Java 线程创建一个本机线程，这些本机线程将消耗额外的系统资源。最后，虽然线程之间

切换的调度开销很小，但如果有很多线程，环境切换也可能严重地影响程序的性能。

如果线程池太大，那么被那些线程消耗的资源可能严重地影响系统性能。在线程之间进行切换将会浪费

时间，而且使用超出比您实际需要的线程可能会引起资源匮乏问题，因为池线程正在消耗一些资源，而

这些资源可能会被其它任务更有效地利用。除了线程自身所使用的资源以外，服务请求时所做的工作可

能需要其它资源，例如 JDBC 连接、套接字或文件。这些也都是有限资源，有太多的并发请求也可能引

起失效，例如不能分配 JDBC 连接。

并发错误

线程池和其它排队机制依靠使用 wait() 和 notify() 方法，这两个方法都难于使用。如果编码不正确，那

么可能丢失通知，导致线程保持空闲状态，尽管队列中有工作要处理。使用这些方法时，必须格外小

心；即便是专家也可能在它们上面出错。而最好使用现有的、已经知道能工作的实现，例如在下面的无

须编写您自己的池中讨论的 util.concurrent 包。

线程泄漏

各种类型的线程池中一个严重的风险是线程泄漏，当从池中除去一个线程以执行一项任务，而在任务完

成后该线程却没有返回池时，会发生这种情况。发生线程泄漏的一种情形出现在任务抛出一个

RuntimeException 或一个 Error 时。如果池类没有捕捉到它们，那么线程只会退出而线程池的大小将

会永久减少一个。当这种情况发生的次数足够多时，线程池最终就为空，而且系统将停止，因为没有可

用的线程来处理任务。

有些任务可能会永远等待某些资源或来自用户的输入，而这些资源又不能保证变得可用，用户可能也已

经回家了，诸如此类的任务会永久停止，而这些停止的任务也会引起和线程泄漏同样的问题。如果某个

线程被这样一个任务永久地消耗着，那么它实际上就被从池除去了。对于这样的任务，应该要么只给予

它们自己的线程，要么只让它们等待有限的时间。

请求过载仅仅是请求就压垮了服务器，这种情况是可能的。在这种情形下，我们可能不想将每个到来的请求都排

队到我们的工作队列，因为排在队列中等待执行的任务可能会消耗太多的系统资源并引起资源缺乏。在

这种情形下决定如何做取决于您自己；在某些情况下，您可以简单地抛弃请求，依靠更高级别的协议稍

后重试请求，您也可以用一个指出服务器暂时很忙的响应来拒绝请求。

有效使用线程池的准则

只要您遵循几条简单的准则，线程池可以成为构建服务器应用程序的极其有效的方法：

不要对那些同步等待其它任务结果的任务排队。这可能会导致上面所描述的那种形式的死锁，在那种死

锁中，所有线程都被一些任务所占用，这些任务依次等待排队任务的结果，而这些任务又无法执行，因

为所有的线程都很忙。

在为时间可能很长的操作使用合用的线程时要小心。如果程序必须等待诸如 I/O 完成这样的某个资源，

那么请指定最长的等待时间，以及随后是失效还是将任务重新排队以便稍后执行。这样做保证了：通过

将某个线程释放给某个可能成功完成的任务，从而将最终取得某些进展。

理解任务

要有效地调整线程池大小，您需要理解正在排队的任务以及它们正在做什么。它们是 CPU 限制的

（CPU-bound）吗？它们是 I/O 限制的（I/O-bound）吗？您的答案将影响您如何调整应用程序。如果

您有不同的任务类，这些类有着截然不同的特征，那么为不同任务类设置多个工作队列可能会有意义，

这样可以相应地调整每个池。

调整池的大小

调整线程池的大小基本上就是避免两类错误：线程太少或线程太多。幸运的是，对于大多数应用程序来

说，太多和太少之间的余地相当宽。

请回忆：在应用程序中使用线程有两个主要优点，尽管在等待诸如 I/O 的慢操作，但允许继续进行处

理，并且可以利用多处理器。在运行于具有 N 个处理器机器上的计算限制的应用程序中，在线程数目接

近 N 时添加额外的线程可能会改善总处理能力，而在线程数目超过 N 时添加额外的线程将不起作用。事

实上，太多的线程甚至会降低性能，因为它会导致额外的环境切换开销。

线程池的最佳大小取决于可用处理器的数目以及工作队列中的任务的性质。若在一个具有 N 个处理器的

系统上只有一个工作队列，其中全部是计算性质的任务，在线程池具有 N 或 N+1 个线程时一般会获得

最大的 CPU 利用率。

对于那些可能需要等待 I/O 完成的任务（例如，从套接字读取 HTTP 请求的任务），需要让池的大小超

过可用处理器的数目，因为并不是所有线程都一直在工作。通过使用概要分析，您可以估计某个典型请

求的等待时间（WT）与服务时间（ST）之间的比例。如果我们将这一比例称之为 WT/ST，那么对于一

个具有 N 个处理器的系统，需要设置大约 N*(1+WT/ST) 个线程来保持处理器得到充分利用。

处理器利用率不是调整线程池大小过程中的唯一考虑事项。随着线程池的增长，您可能会碰到调度程

序、可用内存方面的限制，或者其它系统资源方面的限制，例如套接字、打开的文件句柄或数据库连接

等的数目。

无须编写您自己的池

Doug Lea 编写了一个优秀的并发实用程序开放源码库 util.concurrent，它包括互斥、信号量、诸如在

并发访问下执行得很好的队列和散列表之类集合类以及几个工作队列实现。该包中的 PooledExecutor

类是一种有效的、广泛使用的以工作队列为基础的线程池的正确实现。您无须尝试编写您自己的线程

池，这样做容易出错，相反您可以考虑使用 util.concurrent 中的一些实用程序。

util.concurrent 库也激发了 JSR 166，JSR 166 是一个 Java 社区过程（Java Community Process

(JCP)）工作组，他们正在打算开发一组包含在 java.util.concurrent 包下的 Java 类库中的并发实用程

序，这个包应该用于 Java 开发工具箱 1.5 发行版。UTIL.CONCURRENT包介绍

1概述

纽约奥斯维果州立大学的Doug Lea 编写了一个优秀的并发实用程序开放源码库 util.concurrent，它包

括互斥、信号量、诸如在并发访问下执行得很好的队列和散列表之类集合类以及几个工作队列实现。该

包中的 PooledExecutor 类是一种有效的、广泛使用的以工作队列为基础的线程池的正确实现。该工具

包已经过了大量的测试和实践的考验，是个功能强大的成熟的工具包，在很多著名的服务器如oc4j、

jboss里面您都可以找到util.concurrent的影子。Doug Lea 当时设计这个包的目标就是“简单的接口、高

质量实现”。JSR 166（Java Community Process (JCP)）工作组已计划将 java.util.concurrent 包纳入

JDK 1.5 发行版，正在进行一些标准化的工作，让我们拭目以待。也许很多程序员愿意尝试自己写开发

包，但是最终您会发现，您写的开发包也许并不比Doug Lea写的强大，甚至更容易出错。程序员的青春

和生命是有限的，大量的时间和精力花在重复撰写已有的通用开发包，我认为这通常是不必要的，当然

有志于挑战自我的和想深入研究该问题的读者除外。牛顿曾经很谦虚的说过，他的巨大的成功，是应为

他站在巨人的肩膀上。所以，您并非必须编写您自己的线程池，这样做容易出错，相反您可以考虑使用

util.concurrent 中的一些实用程序。当然这里笔者并不是鼓励大家懒惰得思想，而是认为在具体的情况

下，应该有所取舍，将宝贵的开发时间用在解决更重要的核心问题上来。在这里顺便提一下，Doug Lea

的 《Concurrent Programming in Java, Second Edition》是一本围绕 Java 应用程序中多线程编程方面

可能出现的难解问题的权威著作，有时间的话您可找来读一读。

2 框架与结构

下面让我们来看看util.concurrent的框架结构。关于这个工具包概述的e文原版链接地址是http:

//gee.cs.oswego.edu/dl/cpjslides/util.pdf。该工具包主要包括三大部分：同步、通道和线程池执行

器。第一部分主要是用来定制锁，资源管理，其他的同步用途；通道则主要是为缓冲和队列服务的；线

程池执行器则提供了一组完善的复杂的线程池实现。

--主要的结构如下图所示

2.1 Sync

acquire/release协议的主要接口

- 用来定制锁，资源管理，其他的同步用途

- 高层抽象接口

- 没有区分不同的加锁用法

实现

-Mutex, ReentrantLock, Latch, CountDown,Semaphore, WaiterPreferenceSemaphore,

FIFOSemaphore, PrioritySemaphore

还有，有几个简单的实现，例如ObservableSync, LayeredSync

举例：如果我们要在程序中获得一独占锁，可以用如下简单方式：

try {

lock.acquire();

try {

action();

}

finally {

lock.release();

}

}catch（Exception e）{

}程序中,使用lock对象的acquire()方法获得一独占锁，然后执行您的操作，锁用完后，使用release()方法

释放之即可。呵呵，简单吧，想想看，如果您亲自撰写独占锁，大概会考虑到哪些问题？如果关键的锁

得不到怎末办？用起来是不是会复杂很多？而现在，以往的很多细节和特殊异常情况在这里都无需多考

虑，您尽可以把精力花在解决您的应用问题上去。

2.2 通道(Channel)

为缓冲，队列等服务的主接口

具体实现

LinkedQueue, BoundedLinkedQueue,BoundedBuffer, BoundedPriorityQueue,

SynchronousChannel, Slot

通道例子

class Service { // ...

final Channel msgQ = new LinkedQueue();

public void serve() throws InterruptedException {

String status = doService();

msgQ.put(status);

}

public Service() { // start background thread

Runnable logger = new Runnable() {

public void run() {

try {

for(;;)

System.out.println(msqQ.take());

}

catch(InterruptedException ie) {} }

};

new Thread(logger).start();

}

}

在后台服务器中，缓冲和队列都是最常用到的。试想，如果对所有远端的请求不排个队列，让它们一拥

而上的去争夺cpu、内存、资源，那服务器瞬间不当掉才怪。而在这里，成熟的队列和缓冲实现已经提

供，您只需要对其进行正确初始化并使用即可，大大缩短了开发时间。

2.3执行器(Executor)

Executor是这里最重要、也是我们往往最终写程序要用到的，下面重点对其进行介绍。

类似线程的类的主接口

- 线程池

- 轻量级运行框架

- 可以定制调度算法

只需要支持execute(Runnable r)

- 同Thread.start类似

实现

- PooledExecutor, ThreadedExecutor, QueuedExecutor, FJTaskRunnerGroup

PooledExecutor（线程池执行器）是个最常用到的类，以它为例：

可修改得属性如下：

- 任务队列的类型

- 最大线程数

- 最小线程数

- 预热(预分配)和立即(分配)线程

- 保持活跃直到工作线程结束-- 以后如果需要可能被一个新的代替

- 饱和(Saturation)协议

-- 阻塞，丢弃，生产者运行，等等

可不要小看上面这数条属性，对这些属性的设置完全可以等同于您自己撰写的线程池的成百上千行代

码。下面以笔者撰写过得一个GIS服务器为例：

该GIS服务器是一个典型的“请求－服务”类型的服务器，遵循后端程序设计的一般框架。首先对所有的请

求按照先来先服务排入一个请求队列，如果瞬间到达的请求超过了请求队列的容量，则将溢出的请求转

移至一个临时队列。如果临时队列也排满了，则对以后达到的请求给予一个“服务器忙”的提示后将其简

单抛弃。这个就够忙活一阵的了。

然后，结合链表结构实现一个线程池，给池一个初始容量。如果该池满，以x2的策略将池的容量动态增

加一倍，依此类推，直到总线程数服务达到系统能力上限，之后线程池容量不在增加，所有请求将等待

一个空余的返回线程。每从池中得到一个线程，该线程就开始最请求进行GIS信息的服务，如取坐标、取

地图，等等。服务完成后，该线程返回线程池继续为请求队列离地后续请求服务，周而复始。当时用矢

量链表来暂存请求，用wait()、 notify() 和 synchronized等原语结合矢量链表实现线程池，总共约600行

程序，而且在运行时间较长的情况下服务器不稳定，线程池被取用的线程有异常消失的情况发生。而使

用util.concurrent相关类之后，仅用了几十行程序就完成了相同的工作而且服务器运行稳定，线程池没

有丢失线程的情况发生。由此可见util.concurrent包极大的提高了开发效率，为项目节省了大量的时

间。

使用PooledExecutor例子

import java.net.*;

/**

*

结束语

Title:

*

Description: 负责初始化线程池以及启动服务器

*

Copyright: Copyright (c) 2003

*

Company:

* @author not attributable

* @version 1.0

*/

public class MainServer {

//初始化常量

public static final int MAX_CLIENT=100; //系统最大同时服务客户数

//初始化线程池

public static final PooledExecutor pool =

new PooledExecutor(new BoundedBuffer(10), MAX_CLIENT); //chanel容量为10,

//在这里为线程池初始化了一个

//长度为10的任务缓冲队列。

public MainServer() {

//设置线程池运行参数

pool.setMinimumPoolSize(5); //设置线程池初始容量为5个线程

pool.discardOldestWhenBlocked();//对于超出队列的请求，使用了抛弃策略。

pool.createThreads(2); //在线程池启动的时候，初始化了具有一定生命周期的2个“热”线程

}public static void main(String[] args) {

MainServer MainServer1 = new MainServer();

new HTTPListener().start();//启动服务器监听和处理线程

new manageServer().start();//启动管理线程

}

}

类HTTPListener

import java.net.*;

/**

*

Title:

*

Description: 负责监听端口以及将任务交给线程池处理

*

Copyright: Copyright (c) 2003

*

Company:

* @author not attributable

* @version 1.0

*/

public class HTTPListener extends Thread{

public HTTPListener() {

}

public void run(){

try{

ServerSocket server=null;

Socket clientconnection=null;

server = new ServerSocket(8008);//服务套接字监听某地址端口对

while(true){//无限循环

clientconnection =server.accept();

System.out.println("Client connected in!");

//使用线程池启动服务

MainServer.pool.execute(new HTTPRequest(clientconnection));//如果收到一个请求，则从线程池中

取一个线程进行服务，任务完成后，该线程自动返还线程池

}

}catch(Exception e){

System.err.println("Unable to start serve listen:"+e.getMessage());

e.printStackTrace();

}

}

}

关于util.concurrent工具包就有选择的介绍到这，更详细的信息可以阅读这些java源代码的API文档。

Doug Lea是个很具有“open”精神的作者，他将util.concurrent工具包的java源代码全部公布出来，有兴

趣的读者可以下载这些源代码并细细品味。

线程池是组织服务器应用程序的有用工具。它在概念上十分简单，但在实现和使用一个池时，却需要注

意几个问题，例如死锁、资源不足和 wait() 及 notify() 的复杂性。如果您发现您的应用程序需要线程

池，那么请考虑使用 util.concurrent 中的某个 Executor 类，例如 PooledExecutor，而不用从头开始编

写。如果您要自己创建线程来处理生存期很短的任务，那么您绝对应该考虑使用线程池来替代。