对本书的赞誉

译者序

前　言

第1章　简介

　1.1　并发简史

　1.2　线程的优势

　　1.2.1　发挥多处理器的强大能力

　　1.2.2　建模的简单性

　　1.2.3　异步事件的简化处理

　　1.2.4　响应更灵敏的用户界面

　1.3　线程带来的风险

　　1.3.1　安全性问题

　　1.3.2　活跃性问题

　　1.3.3　性能问题

　1.4　线程无处不在

第一部分　基础知识

　第2章　线程安全性

　　2.1　什么是线程安全性

　　2.2　原子性

　　　2.2.1　竞态条件

　　　2.2.2　示例：延迟初始化中的竞态条件

　　　2.2.3　复合操作

　　2.3　加锁机制

　　　2.3.1　内置锁

　　　2.3.2　重入

　　2.4　用锁来保护状态

　　2.5　活跃性与性能

　第3章　对象的共享

　　3.1　可见性

　　　3.1.1　失效数据

　　　3.1.2　非原子的64位操作

　　　3.1.3　加锁与可见性

　　　3.1.4　Volatile变量

　　3.2　发布与逸出

　　3.3　线程封闭

　　　3.3.1　Ad-hoc线程封闭

　　　3.3.2　栈封闭

　　　3.3.3　ThreadLocal类

　　3.4　不变性

　　　3.4.1　Final域

　　　3.4.2　示例：使用Volatile类型来发布不可变对象

　　3.5　安全发布

　　　3.5.1　不正确的发布：正确的对象被破坏

　　　3.5.2 　不可变对象与初始化安全性

　　　3.5.3　安全发布的常用模式

　　　3.5.4　事实不可变对象

　　　3.5.5　可变对象

　　　3.5.6　安全地共享对象

　第4章　对象的组合

　　4.1　设计线程安全的类

　　　4.1.1　收集同步需求

　　　4.1.2　依赖状态的操作

　　　4.1.3　状态的所有权

　　4.2　实例封闭

　　　4.2.1　java监视器模式

　　　4.2.2　示例：车辆追踪

　　4.3　线程安全性的委托

　　　4.3.1　示例：基于委托的车辆追踪器

　　　4.3.2　独立的状态变量

　　　4.3.3　当委托失效时

　　　4.3.4　发布底层的状态变量

　　　4.3.5　示例：发布状态的车辆追踪器

　　4.4　在现有的线程安全类中添加功能

　　　4.4.1　客户端加锁机制

　　　4.4.2　组合

　　4.5　将同步策略文档化

　第5章　基础构建模块

　　5.1　同步容器类

　　　5.1.1　同步容器类的问题

　　　5.1.2　迭代器与Concurrent-ModificationException

　　　5.1.3　隐藏迭代器

　　5.2　并发容器

　　　5.2.1　ConcurrentHashMap

　　　5.2.2　额外的原子Map操作

　　　5.2.3　CopyOnWriteArrayList

　　5.3　阻塞队列和生产者-消费者模式

　　　5.3.1　示例：桌面搜索

　　　5.3.2　串行线程封闭

　　　5.3.3　双端队列与工作密取

　　5.4　阻塞方法与中断方法

　　5.5　同步工具类

　　　5.5.1　闭锁

　　　5.5.2　FutureTask

　　　5.5.3　信号量

　　　5.5.4　栅栏

　　5.6　构建高效且可伸缩的结果缓存

第二部分　结构化并发应用程序

　第6章　任务执行

　　6.1　在线程中执行任务

　　　6.1.1　串行地执行任务

　　　6.1.2　显式地为任务创建线程

　　　6.1.3　无限制创建线程的不足

　　6.2　Executor框架

　　　6.2.1　示例：基于Executor的web服务器

　　　6.2.2　执行策略

　　　6.2.3　线程池

　　　6.2.4　Executor的生命周期

　　　6.2.5　延迟任务与周期任务

　　6.3　找出可利用的并行性

　　　6.3.1　示例：串行的页面渲染器

　　　6.3.2　携带结果的任务Callable与Future

　　　6.3.3　示例：使用Future实现页面渲染器

　　　6.3.4　在异构任务并行化中存在的局限

　　　6.3.5　CompletionService:Executor与BlockingQueue

　　　6.3.6　示例：使用CompletionService实现页面渲染器

　　　6.3.7　为任务设置时限

　　　6.3.8　示例：旅行预定门户网站

　第7章　取消与关闭

　　7.1　任务取消

　　　7.1.1　中断

　　　7.1.2　中断策略

　　　7.1.3　响应中断

　　　7.1.4　示例：计时运行

　　　7.1.5　通过Future来实现取消

　　　7.1.6　处理不可中断的阻塞

　　　7.1.7　采用newTaskFor来封装非标准的取消

　　7.2　停止基于线程的服务

　　　7.2.1　示例：日志服务

　　　7.2.2　关闭ExecutorService

　　　7.2.3　“毒丸”对象

　　　7.2.4　示例：只执行一次的服务

　　　7.2.5　shutdownNow的局限性

　　7.3　处理非正常的线程终止

　　7.4　JVM关闭

　　　7.4.1　关闭钩子

　　　7.4.2　守护线程

　　　7.4.3　终结器

　第8章　线程池的使用

　　8.1　在任务与执行策略之间的隐性耦合

　　　8.1.1　线程饥饿死锁

　　　8.1.2　运行时间较长的任务

　　8.2　设置线程池的大小

　　8.3　配置ThreadPoolExecutor

　　　8.3.1　线程的创建与销毁

　　　8.3.2　管理队列任务

　　　8.3.3　饱和策略

　　　8.3.4　线程工厂

　　　8.3.5　在调用构造函数后再定制ThreadPoolExecutor

　　8.4　扩展 ThreadPoolExecutor

　　8.5　递归算法的并行化

　第9章　图形用户界面应用程序

　　9.1　为什么GUI是单线程的

　　　9.1.1　串行事件处理

　　　9.1.2　Swing中的线程封闭机制

　　9.2　短时间的GUI任务

　　9.3　长时间的GUI任务

　　　9.3.1　取消

　　　9.3.2　进度标识和完成标识

　　　9.3.3　SwingWorker

　　9.4　共享数据模型

　　　9.4.1　线程安全的数据模型

　　　9.4.2　分解数据模型

　　　9.5　其他形式的单线程子系统

第三部分　活跃性、性能与测试

　第10章　避免活跃性危险

　　10.1　死锁

　　　10.1.1　锁顺序死锁

　　　10.1.2　动态的锁顺序死锁

　　　10.1.3　在协作对象之间发生的死锁

　　　10.1.4　开放调用

　　　10.1.5　资源死锁

　　10.2　死锁的避免与诊断

　　　10.2.1　支持定时的锁

　　　10.2.2　通过线程转储信息来分析死锁

　　10.3　其他活跃性危险

　　　10.3.1　饥饿

　　　10.3.2　糟糕的响应性

　　　10.3.3　活锁

　第11章　性能与可伸缩性

　　11.1　对性能的思考

　　　11.1.1　性能与可伸缩性

　　　11.1.2　评估各种性能权衡因素

　　11.2　Amdahl定律

　　　11.2.1　示例：在各种框架中隐藏的串行部分

　　　11.2.2　Amdahl定律的应用

　　11.3　线程引入的开销

　　　11.3.1　上下文切换

　　　11.3.2　内存同步

　　　11.3.3　阻塞

　　11.4　减少锁的竞争

　　　11.4.1　缩小锁的范围（“快进快出”）

　　　11.4.2　减小锁的粒度

　　　11.4.3　锁分段

　　　11.4.4　避免热点域

　　　11.4.5　一些替代独占锁的方法

　　　11.4.6　监测CPU的利用率

　　　11.4.7　向对象池说“不”

　　11.5　示例：比较Map的性能

　　11.6　减少上下文切换的开销

　第12章　并发程序的测试

　　12.1　正确性测试

　　　12.1.1　基本的单元测试

　　　12.1.2　对阻塞操作的测试

　　　12.1.3　安全性测试

　　　12.1.4　资源管理的测试

　　　12.1.5　使用回调

　　　12.1.6　产生更多的交替操作

　　12.2　性能测试

　　　12.2.1　在PutTakeTest中增加计时功能

　　　12.2.2　多种算法的比较

　　　12.2.3　响应性衡量

　　12.3　避免性能测试的陷阱

　　　12.3.1　垃圾回收

　　　12.3.2　动态编译

　　　12.3.3　对代码路径的不真实采样

　　　12.3.4　不真实的竞争程度

　　　12.3.5　无用代码的消除

　　12.4　其他的测试方法

　　　12.4.1　代码审查

　　　12.4.2　静态分析工具

　　　12.4.3　面向方面的测试技术

　　　12.4.4　分析与监测工具

第四部分　高级主题

　第13章　显式锁

　　13.1　Lock与 ReentrantLock

　　　13.1.1　轮询锁与定时锁

　　　13.1.2　可中断的锁获取操作

　　　13.1.3　非块结构的加锁

　　13.2　性能考虑因素

　　13.3　公平性

　　13.4　在synchronized和ReentrantLock之间进行选择

　　13.5　读-写锁

　第14章　构建自定义的同步工具

　　14.1　状态依赖性的管理

　　　14.1.1　示例：将前提条件的失败传递给调用者

　　　14.1.2　示例：通过轮询与休眠来实现简单的阻塞

　　　14.1.3　条件队列

　　14.2　使用条件队列

　　　14.2.1　条件谓词

　　　14.2.2　过早唤醒

　　　14.2.3　丢失的信号

　　　14.2.4　通知

　　　14.2.5　示例：阀门类

　　　14.2.6　子类的安全问题

　　　14.2.7　封装条件队列

　　　14.2.8　入口协议与出口协议

　　14.3　显式的Condition对象

　　14.4　Synchronizer剖析

　　14.5　AbstractQueuedSynchronizer

　　14.6　java.util.concurrent同步器类中的 AQS

　　　14.6.1　ReentrantLock

　　　14.6.2　SEMaphore与CountDownLatch

　　　14.6.3　FutureTask

　　　14.6.4　ReentrantReadWriteLock

　第15章　原子变量与非阻塞同步机制

　　15.1　锁的劣势

　　15.2　硬件对并发的支持

　　　15.2.1　比较并交换

　　　15.2.2　非阻塞的计数器

　　　15.2.3　JVM对CAS的支持

　　15.3　原子变量类

　　　15.3.1　原子变量是一种“更好的volatile”

　　　15.3.2　性能比较：锁与原子变量

　　15.4　非阻塞算法

　　　15.4.1　非阻塞的栈

　　　15.4.2　非阻塞的链表

　　　15.4.3　原子的域更新器

　　　15.4.4　ABA问题

　第16章　Java内存模型

　　16.1　什么是内存模型，为什么需要它

　　　16.1.1　平台的内存模型

　　　16.1.2　重排序

　　　16.1.3　Java内存模型简介

　　　16.1.4　借助同步

　　16.2　发布

　　　16.2.1　不安全的发布

　　　16.2.2　安全的发布

　　　16.2.3　安全初始化模式

　　　16.2.4　双重检查加锁

　　16.3　初始化过程中的安全性

附录A　并发性标注

参考文献

　　在写作本书时，对于中端桌面系统来说，多核处理器正变得越来越便宜。无独有偶，许多开发团队也注意到，在他们的项目中出现了越来越多与线程有关的错误报告。在NetBeans开发者网站上的最近一次公告中，一位核心维护人员注意到，为了修复与线程相关的问题，在某个类中竟然打了14次补丁。Dion Almaer，这位TheServerSide网站的前编辑，最近(在经过一番痛苦的调试过程并最终发现了一个与线程有关的错误之后)在其博客上写道，在大多数Java程序中充满了各种并发错误，使得程序只有在“偶然的情况下”才能正常工作。

确实，在开发、测试以及调试多线程程序时存在着巨大的困难，因为并发性错误通常并不会以某种确定的方式显现出来。当这些错误出现时，通常是在最糟糕的时刻，例如在正式产品中，或者在高负载的情况下。

当开发Java并发程序时，所要面对的挑战之一就是：平台提供的各种并发功能与开发人员在程序中需要的并发语义并不匹配。在Java语言中提供了一些底层机制，例如同步和条件等待，但在使用这些机制来实现应用级的协议与策略时必须始终保持一致。如果没有这些策略，那么在编写程序时，虽然程序看似能顺利地编译和运行，但却总会出现各种奇怪的问题。许多介绍并发的其他书籍更侧重于介绍一些底层机制和API，而在设计级的策略和模式上叙述的不多。

Java 5.0在Java并发应用程序的开发方面进展巨大，它不仅提供了一些新的高层组件，还补充了一些底层机制，从而使得无论是新手级开发人员还是专家级开发人员都能够更容易地构建并发应用程序。本书的作者都是JCP专家组的主要成员，也正是该专家组编写了这些新功能。本书不仅描述了这些新功能的行为和特性，还介绍了它们的底层设计模式和促使它们被添加到平台库中的应用场景。

我们的目标是向读者介绍一些设计规则和思维模式，从而使读者能够更容易也更乐意去构建正确的以及高性能的Java并发类和应用程序。

我们希望你能享受本书的阅读过程。

Brian Goetz　　

Williston，VT　　

2006年3月

如何使用本书

为了解决在Java底层机制与设计级策略之间的不匹配问题，我们给出了一组简化的并发程序编写规则。专家看到这些规则会说：“嗯，这并不是完整的规则集。即使类C违背了规则R，它仍然是线程安全的。”虽然在违背一些规则的情况下仍有可能编写出正确的并发程序，但这需要对Java内存模型的底层细节有着深入的理解，而我们希望开发人员无须掌握这些细节就能编写出正确的并发程序。只要始终遵循这组简单的规则，就能编写出正确的并且可维护的并发程序。

我们假设读者对Java的基本并发机制已经有了一定程度的了解。本书并非是对并发的入门介绍—要了解这方面的内容，请参考其他书籍中有关线程的内容，例如《The Java Programming Language》（Arnold等，2005）。此外，本书也不是介绍并发的百科全书—要了解这方面的内容，请参考《Concurrent Programming in Java》（Lea，2000）。事实上，本书提供了各种实用的设计规则，用于帮助开发人员创建安全的和高性能的并发类。在本书中相应的地方引用了以下书籍中的相关章节：《The Java Programming Language》、《Concurrent Programming in Java》、《The Java Language Specification》 ( Gosling等，2005 )以及《Effective Java 》（Bloch, 2001)，并分别使用[JPL n.m]、[CPJ n.m]、[JLS n.m]和[EJ Item n]来表示它们。

在进行简要的介绍（第1章）之后，本书共分为四个部分:

基础知识。第一部分（第2章～第5章）重点介绍了并发性和线程安全性的基本概念，以及如何使用类库提供的基本并发构建块来构建线程安全类。在第一部分给出了一个清单，其中总结了这一部分中介绍的最重要的规则。

第2章与第3章构成了本书的基础。在这两章中给出了几乎所有用于避免并发危险、构造线程安全的类以及验证线程安全的规则。如果读者重“实践”而轻“理论”，那么可能会直接跳到第二部分，但在开始编写任何并发代码之前，一定要回来读一读这两章!

第4章介绍了如何将一些小的线程安全类组合成更大的线程安全类。第5章介绍了在平台库中提供的一些基础的并发构建模块，包括线程安全的容器类和同步工具类。

结构化并发应用程序。第二部分（第6章～第9章）介绍了如何利用线程来提高并发应用程序的吞吐量或响应性。第6章介绍了如何识别可并行执行的任务，以及如何在任务执行框架中执行它们。第7章介绍了如何使任务和线程在执行完正常工作之前提前结束。在健壮的并发应用程序与看似能正常工作的应用程序之间存在的重要差异之一就是，如何实现取消以及关闭等操作。第8章介绍了任务执行框架中的一些更高级特性。第9章介绍了如何提高单线程子系统的响应性。

活跃性、性能与测试。第三部分(第10章～第12章)介绍了如何确保并发程序执行预期的任务，以及如何获得理想的性能。第10章介绍了如何避免一些使程序无法执行下去的活跃性故障。第11章介绍了如何提高并发代码的性能和可伸缩性。第12章介绍了在测试并发代码的正确性和性能时可以采用的一些技术。

高级主题。第四部分（第13章～第16章）介绍了资深开发人员可能感兴趣的一些主题，包括：显式锁、原子变量、非阻塞算法以及如何开发自定义的同步工具类。

代码示例

虽然书中很多一般性的概念同样适用于Java 5.0之前的版本以及一些非Java的运行环境，但其中大多数示例代码（以及关于Java内存模型的所有描述）是基于Java 5.0或更高版本的，而且某些代码示例中还使用了Java 6的一些新增功能。

我们对书中的代码示例已经进行了压缩，以便减少代码量并重点突出与内容相关的部分。在本书的网站http://www.javaconcurrencyinpractice.com上提供了完整的代码示例、辅助示例以及勘误表。

代码示例可分为三类：“好的”示例、“一般的”示例和“糟糕的”示例。“好的”示例是应该被效仿的技术。“糟糕的”示例是一定不能效仿的技术，而且还会用一个“Mr. Yuk”的图标来表示该示例中的代码是“有害的”(参见程序清单1)。“一般的”示例给出的技术并不一定是错的，但却是脆弱的、有风险的或是性能较差的，并且会用一个“Mr.Could Be Happier”图标来表示，如程序清单2所示。

程序清单1　糟糕的链表排序方式（不要这样做）

public > void sort(List list) {

// 永远不要返回错误的答案！

System.exit(0);

}

有些读者会质疑这些“糟糕的”示例在本书中的作用，毕竟，在一本书中应该给出如何做正确的事，而不是错误的事。这些“糟糕的”示例有两个目的，它们揭示了一些常见的缺陷，但更重要的是它们示范了如何分析程序的线程安全性，而要实现这个目的，最佳的方式就是观察线程安全性是如何被破坏的。

程序清单2　非最优方式的链表排序

public > void sort(List list) {

for (int i=0; i<1000000; i++)

doNothing();

Collections.sort(list);

}

　　致谢

本书诞生于Java Community Process JSR 166 为Java 5.0开发java.util.concurrent包的过程中。还有许多人参与到JSR 166中，特别感谢Martin Buchholz将全部的工作融入到JDK中，并感谢concurrency-interest邮件列表中的所有读者对API草案提出的建议和反馈。

有不少来自各方面的人员都提出了建议和帮助，使得本书的内容得到了极大的充实。感谢Dion Almaer、Tracy Bialik、Cindy Bloch、Martin Buchholz、Paul Christmann、Cliff Click、Stuart Halloway、David Hovemeyer、Jason Hunter、Michael Hunter、Jeremy Hylton、Heinz Kabutz、Robert Kuhar、Ramnivas Laddad、Jared Levy、Nicole Lewis、Victor Luchangco、Jeremy Manson、Paul Martin、Berna Massingill、Michael Maurer、Ted Neward、Kirk Pepperdine、Bill Pugh、Sam Pullara、Russ Rufer、Bill Scherer、Jeffrey Siegal、Bruce Tate、Gil Tene、Paul Tyma，以及硅谷模式小组的所有成员，他们通过各种技术交流为本书提供了指导建议，使得本书更加完善。

特别感谢Cliff Biffle、Barry Hayes、Dawid Kurzyniec、Angelika Langer、Doron Rajwan和Bill Venners，他们非常仔细地审阅了本书的全稿，指出了代码示例中的错误，并提出了大量的改进建议。

感谢Katrina Avery的编辑工作，以及Rosemary Simpson在非常短的时间里完成了索引生成工作。感谢Ami Dewar绘制的插图。

感谢Addison-Wesley的全体成员，他们使本书得以最终问世。Ann Sellers启动了编写本书的项目，Greg Doench监督并帮助本书有条不紊地完成，Elizabeth Ryan负责本书的出版过程。

此外还要感谢许许多多的软件工程师，他们开发了本书得以依赖的各种软件，这些软件包括TEX、LATEX、Adobe Acrobat、pic、grap、Adobe Illustrator、Perl、Apache Ant、IntelliJ IDEA、GNU emacs、Subversion、TortoiseSVN，当然，还有Java平台及其类库。