9787121382451 9787121310652

书名: Java多线程编程实战指南-设计模式篇(2版)

作者: 黄文海

定价: 69.00元

ISBN编号: 9787121382451

开本: 16开

是否是套装: 否

出版社名称: 电子工业出版社



  随着CPU多核时代的到来，多线程编程在充分利用计算资源、提高软件服务质量方面扮演了越来越重要的角色。解决多线程编程中频繁出现的普遍问题可以借鉴设计模式所提供的现成解决方案。然而，多线程编程相关的设计模式图书多采用C++作为描述语言，且书中所举的例子多与应用开发人员的实际工作相去甚远。本书采用Java语言和UML为描述语言，并结合作者多年工作经历及相关实践经验，介绍了多线程环境下常用设计模式的来龙去脉：各个设计模式是什么样的、典型的实际应用场景、实际应用时需要注意的事项及各个设计模式的可复用代码实现。本书2版除更正了1版中的错误外，还新增了JDK 8、JDK 9中与多线程设计模式相关的内容，并对代码进行了重构和重新排版，使代码部分重点更突出、更易于阅读，以及提高了插图的清晰度。本书适合有一定Java多线程编程基础、经验的读者阅读。


1章 Java多线程编程实战基础 1
1.1 无处不在的线程 1
1.2 线程的创建与运行 3
1.3 线程的状态与上下文切换 5
1.4 对线程的监视 8
1.5 原子性、内存可见性和重排序——重新认识synchronized
和volatile 11
1.6 多线程编程的优势和风险 13
1.7 多线程编程常用术语 14
2章 设计模式简介 19
2.1 设计模式及其作用 19
2.2 多线程设计模式简介 22
2.3 设计模式的描述 23
3章 Immutable Object（不可变对象）模式 25
3.1 Immutable Object模式简介 25
3.2 Immutable Object模式的架构 27
3.3 Immutable Object模式实战案例解析 29
3.4 Immutable Object模式的评价与实现考量 33
3.4.1 适用场景 33
3.4.2 对垃圾回收（Garbage Collection）的影响 34
3.4.3 使用等效或者近似的不可变对象 35
3.4.4 防御性复制 35
3.5 Immutable Object模式的可复用实现代码 35
3.6 Java标准库实例 35
3.7 相关模式 37
3.7.1 Thread Specific Storage模式（10章） 37
3.7.2 Serial Thread Confinement模式（11章） 37
3.8 参考资源 38
4章 Guarded Suspension（保护性暂挂）模式 39
4.1 Guarded Suspension模式简介 39
4.2 Guarded Suspension模式的架构 39
4.3 Guarded Suspension模式实战案例解析 43
4.4 Guarded Suspension模式的评价与实现考量 50
4.4.1 内存可见性和锁泄漏（Lock Leak） 51
4.4.2 线程被过早地唤醒 52
4.4.3 嵌套监视器锁死 53
4.5 Guarded Suspension模式的可复用实现代码 56
4.6 Java标准库实例 56
4.7 相关模式 56
4.7.1 Promise模式（6章） 57
4.7.2 Producer-Consumer模式（7章） 57
4.8 参考资源 57
5章 Two-phase Termination（两阶段终止）模式 58
5.1 Two-phase Termination模式简介 58
5.2 Two-phase Termination模式的架构 59
5.3 Two-phase Termination模式实战案例解析 61
5.4 Two-phase Termination模式的评价与实现考量 70
5.4.1 线程停止标志 71
5.4.2 生产者/消费者问题中的线程停止 71
5.4.3 隐藏而非暴可停止线程 73
5.5 Two-phase Termination模式的可复用实现代码 73
5.6 Java标准库实例 73
5.7 相关模式 74
5.7.1 Producer-Consumer模式（7章） 74
5.7.2 Master-Slave模式（12章） 74
5.8 参考资源 74
6章 Promise（承诺）模式 75
6.1 Promise模式简介 75
6.2 Promise模式的架构 75
6.3 Promise模式实战案例解析 78
6.4 Promise模式的评价与实现考量 81
6.4.1 异步方法的异常处理 82
6.4.2 轮询 82
6.4.3 异步任务的执行 83
6.5 Promise模式的可复用实现代码 84
6.6 Java标准库实例 85
6.7 相关模式 85
6.7.1 Guarded Suspension模式（4章） 85
6.7.2 Active Object模式（8章） 86
6.7.3 Master-Slave模式（12章） 86
6.7.4 Factory Method（工厂方法）模式 86
6.8 参考资源 86
7章 Producer-Consumer（生产者/消费者）模式 87
7.1 Producer-Consumer模式简介 87
7.2 Producer-Consumer模式的架构 87
7.3 Producer-Consumer模式实战案例解析 90
7.4 Producer-Consumer模式的评价与实现考量 93
7.4.1 产品的粒度 94
7.4.2 通道积压 94
7.4.3 非阻塞式反压与Reactive Streams规范 96
7.4.4 工作窃取算法 97
7.4.5 线程的停止 101
7.4.6 高性能、高可靠性的Producer-Consumer模式实现 101
7.5 Producer-Consumer模式的可复用实现代码 102
7.6 Java标准库实例 102
7.7 相关模式 102
7.7.1 Guarded Suspension模式（4章） 102
7.7.2 Thread Pool模式（9章） 103
7.8 参考资源 103
8章 Active Object（主动对象）模式 104
8.1 Active Object模式简介 104
8.2 Active Object模式的架构 105
8.3 Active Object模式实战案例解析 108
8.4 Active Object模式的评价与实现考量 115
8.4.1 错误隔离 117
8.4.2 缓冲区监控 118
8.4.3 缓冲区饱和处理策略 118
8.4.4 Scheduler空闲工作者线程清理 119
8.5 Active Object模式的可复用实现代码 119
8.6 Java标准库实例 123
8.7 相关模式 123
8.7.1 Promise模式（6章） 123
8.7.2 Producer-Consumer模式（7章） 123
8.8 参考资源 124
9章 Thread Pool（线程池）模式 125
9.1 Thread Pool模式简介 125
9.2 Thread Pool模式的架构 126
9.3 Thread Pool模式实战案例解析 128
9.4 Thread Pool模式的评价与实现考量 130
9.4.1 工作队列的选择 131
9.4.2 线程池大小调校 132
9.4.3 线程池监控 134
9.4.4 线程泄漏 135
9.4.5 可靠性与线程池饱和处理策略 135
9.4.6 死锁 138
9.4.7 线程池空闲线程清理 139
9.5 Thread Pool模式的可复用实现代码 140
9.6 Java标准库实例 140
9.7 相关模式 140
9.7.1 Two-phase Termination模式（5章） 140
9.7.2 Promise模式（6章） 141
9.7.3 Producer-Consumer模式（7章） 141
9.8 参考资源 141
10章 Thread Specific Storage（线程特有存储）模式 142
10.1 Thread Specific Storage模式简介 142
10.2 Thread Specific Storage模式的架构 144
10.3 Thread Specific Storage模式实战案例解析 146
10.4 Thread Specific Storage模式的评价与实现考量 149
10.4.1 在线程池环境下使用Thread Specific Storage模式 153
10.4.2 内存泄漏与伪内存泄漏 153
10.5 Thread Specific Storage模式的可复用实现代码 161
10.6 Java标准库实例 161
10.7 相关模式 162
10.7.1 Immutable Object模式（3章） 162
10.7.2 Proy（代理）模式 162
10.7.3 Singleton（单例）模式 162
10.8 参考资源 162
11章 Serial Thread Confinement（串行线程封闭）模式 163
11.1 Serial Thread Confinement模式简介 163
11.2 Serial Thread Confinement模式的架构 163
11.3 Serial Thread Confinement模式实战案例解析 166
11.4 Serial Thread Confinement模式的评价与实现考量 170
11.5 Serial Thread Confinement模式的可复用实现代码 171
11.6 Java标准库实例 176
11.7 相关模式 177
11.7.1 Immutable Object模式（3章） 177
11.7.2 Promise模式（6章） 177
11.7.3 Producer-Consumer模式（7章） 177
11.7.4 Thread Specific Storage模式（10章） 177
11.8 参考资源 177
12章 Master-Slave（主仆）模式 178
12.1 Master-Slave模式简介 178
12.2 Master-Slave模式的架构 178
12.3 Master-Slave模式实战案例解析 180
12.4 Master-Slave模式的评价与实现考量 187
12.4.1 子任务处理结果的收集 188
12.4.2 Slave参与者实例的负载均衡与工作窃取 189
12.4.3 可靠性与异常处理 190
12.4.4 Slave线程的停止 190
12.5 Master-Slave模式的可复用实现代码 190
.....



书名：Java多线程编程实战指南（核心篇）  

丛书名 ：Java多线程编程实战系列

作 译 者：黄文海

出版时间：2017-04    

千 字 数：618

版    次：01-01    

页    数：480

开    本：16开

I S B N ：9787121310652    

定价：89.0  




一部分  多线程编程基础

1章  走近Java世界中的线程    2

1.1  进程、线程与任务    2

1.2  多线程编程简介    4

1.2.1  什么是多线程编程    4

1.2.2  为什么使用多线程    4

1.3  Java线程API简介    5

1.3.1  线程的创建、启动与运行    5

1.3.2  Runnable接口    9

1.3.3  线程属性    12

1.3.4  Thread类的常用方法    14

1.3.5  Thread类的一些废弃方法    16

1.4  无处不在的线程    17

1.5  线程的层次关系    19

1.6  线程的生命周期状态    21

1.7  线程的监视    22

1.8  多线程编程简单运用实例    26

*1.9  多线程编程的优势和风险    27

1.10  本章小结    29

2章  多线程编程的目标与挑战    31

2.1  串行、并发与并行    31

2.2  竞态    33

2.2.1  二维表分析法：解释竞态的结果    37

2.2.2  竞态的模式与竞态产生的条件    39

2.3  线程安全性    42

2.4  原子性    43

2.5  可见性    49

2.6  有序性    56

2.6.1  重排序的概念    56

2.6.2  指令重排序    57

2.6.3  存储子系统重排序    63

2.6.4  貌似串行语义    66

2.6.5  保证内存访问的顺序性    68

2.7  上下文切换    69

2.7.1  上下文切换及其产生原因    69

2.7.2  上下文切换的分类及具体诱因    70

2.7.3  上下文切换的开销和测量    71

2.8  线程的活性故障    73

2.9  资源争用与调度    74

2.10  本章小结    77

3章  Java线程同步机制    80

3.1  线程同步机制简介    80

3.2  锁概述    81

3.2.1  锁的作用    82

3.2.2  与锁相关的几个概念    84

3.2.3  锁的开销及其可能导致的问题    86

3.3  内部锁：synchronized关键字    86

3.4  显式锁：Lock接口    89

3.4.1  显式锁的调度    91

3.4.2  显式锁与内部锁的比较    92

3.4.3  内部锁还是显式锁：锁的选用    95

*3.4.4  改进型锁：读写锁    95

3.5  锁的适用场景    99

3.6  线程同步机制的底层助手：内存屏障    99

*3.7  锁与重排序    102

3.8  轻量级同步机制：volatile关键字    105

3.8.1  volatile的作用    105

3.8.2  volatile变量的开销    111

3.8.3  volatile的典型应用场景与实战案例    111

3.9  实践：正确实现看似简单的单例模式    120

3.10  CAS与原子变量    126

3.10.1  CAS    127

3.10.2  原子作工具：原子变量类    129

3.11  对象的发布与逸出    135

3.11.1  对象的初始化安全：重访final与static    137

3.11.2  安全发布与逸出    142

3.12  本章小结    143

4章  牛刀小试：玩转线程    148

4.1  挖掘可并发点    148

4.2  新战场上的老武器：分而治之    148

4.3  基于数据的分割实现并发化    149

4.4  基于任务的分割实现并发化    158

4.4.1  按任务的资源消耗属性分割    159

4.4.2  实战案例的启发    169

4.4.3  按处理步骤分割    171

4.5  合理设置线程数    172

4.5.1  Amdahl＇s定律    172

4.5.2  线程数设置的原则    173

4.6  本章小结    177

5章  线程间协作    179

5.1  等待与通知：wait/tify    179

5.1.1  wait/tify的作用与用法    180

5.1.2  wait/tify的开销及问题    188

5.1.3  Object.tify()/tifyAll()的选用    191

*5.1.4  wait/tify与Thread.join()    191

5.2  Java条件变量    192

5.3  倒计时协调器：CountDownLatch    198

5.4  栅栏（CyclicBarrier）    203

5.5  生产者—消费者模式    210

5.5.1  阻塞队列    213

5.5.2  限购：流量控制与信号量（Semaphore）    216

*5.5.3  管道：线程间的直接输出与输入    218

5.5.4  一手交钱，一手交货：双缓冲与Echanger    221

5.5.5  一个还是一批：产品的粒度    223

5.5.6  再探线程与任务之间的关系    224

5.6  对不起，打扰一下：线程中断机制    225

5.7  线程停止：看似简单，实则不然    228

5.7.1  生产者—消费者模式中的线程停止    233

5.7.2  实践：Web应用中的线程停止    233

5.8  本章小结    236

6章  保障线程安全的设计技术    240

*6.1  Java运行时存储空间    240

6.2  大公无私：无状态对象    243

6.3  以“不变”应万变：不可变对象    248

6.4  我有我地盘：线程特有对象    254

6.4.1  线程特有对象可能导致的问题及其规避    258

6.4.2  线程特有对象的典型应用场景    264

6.5  装饰器模式    265

6.6  并发集合    267

6.7  本章小结    270

7章  线程的活性故障    273

7.1  鹬蚌相争：死锁    273

7.1.1  死锁的检测    274

7.1.2  死锁产生的条件与规避    283

7.1.3  死锁的恢复    296

7.2  沉睡不醒的睡美人：锁死    301

7.2.1  信号丢失锁死    301

7.2.2  嵌套监视器锁死    301

7.3  巧妇难为无米之炊：线程饥饿    307

7.4  屡战屡败，屡败屡战：活锁    307

7.5  本章小结    308

8章  线程管理    310

8.1  线程组    310

8.2  可靠性：线程的未捕获异常与监控    311

8.3  有组织有纪律：线程工厂    316

8.4  线程的暂挂与恢复    318

8.5  线程的高效利用：线程池    320

8.5.1  任务的处理结果、异常处理与取消    326

8.5.2  线程池监控    329

8.5.3  线程池死锁    330

8.5.4  工作者线程的异常终止    330

8.6  本章小结    331

9章  Java异步编程    333

9.1  同步计算与异步计算    333

9.2  Java Eecutor框架    336

9.2.1  实用工具类Eecutors    337

9.2.2  异步任务的批量执行：CompletionService    339

9.3  异步计算助手：FutureTask    344

9.3.1  实践：实现XML文档的异步解析    345

9.3.2  可重复执行的异步任务    349

9.4  计划任务    352

9.5  本章小结    358

10章  Java多线程程序的调试与测试    360

10.1  多线程程序的调试技巧    360

10.1.1  使用监视点    360

10.1.2  设置暂挂策略    361

10.2  多线程程序的测试    363

10.2.1  可测试性    364

10.2.2  静态检查工具：FindBugs    369

10.2.3  多线程程序的代码复审    370

10.2.4  多线程程序的单元测试：JCStress    372

10.3  本章小结    375

二部分  多线程编程进阶

11章  多线程编程的硬件基础与Java内存模型    378

11.1  填补处理器与内存之间的鸿沟：高速缓存    378

11.2  数据世界的交通规则：缓存一致性协议    382

11.3  硬件缓冲区：写缓冲器与无效化队列    386

11.3.1  存储转发    388

11.3.2  再探内存重排序    388

11.3.3  再探可见性    391

11.4  基本内存屏障    392

11.5  Java同步机制与内存屏障    395

11.5.1  volatile关键字的实现    395

11.5.2  synchronized关键字的实现    397

11.5.3  Java虚拟机对内存屏障使用的优化    398

11.5.4  final关键字的实现    398

11.6  Java内存模型    399

11.6.1  什么是Java内存模型    400

11.6.2  happen(s)-before关系    401

11.6.3  再探对象的安全发布    407

11.6.4  JSR 133    411

11.7  共享变量与性能    411

11.8  本章小结    411



12章  Java多线程程序的性能调校    415

12.1  Java虚拟机对内部锁的优化    415

12.1.1  锁消除    415

12.1.2  锁粗化    417

12.1.3  偏向锁    419

12.1.4  适应性锁    420

12.2  优化对锁的使用    421

12.2.1  锁的开销与锁争用监视    421

12.2.2  使用可参数化锁    424

12.2.3  减小临界区的长度    428

12.2.4  减小锁的粒度    432

12.2.5  考虑锁的替代品    438

12.3  减少系统内耗：上下文切换    438

12.4  多线程编程的“三十六计”：多线程设计模式    440

12.5  性能的隐形杀手：伪共享    441

12.5.1  Java对象内存布局    442

12.5.2  伪共享的侦测与消除    445

12.6  本章小结    454

Web参考资源    457

参考文献    463




随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了——如今就连智能手机这样的消费类设备都已配备了4核乃至8核的处理器，更何况商用系统！在此背景下，以往靠单个处理器自身处理能力的提升所带来的软件计算性能提升的那种“免费午餐”已不复存在，这使得多线程编程在充分利用计算资源、提高软件服务质量方面扮演了越来越重要的角色。故而，掌握多线程编程技能对广大开发人员的重要性亦由此可见一斑。本书以基本概念、原理与方法为主线，辅以丰富的实战案例和生活化实例，并从Java虚拟机、作系统和硬件多个层次与角度出发，循序渐进、系统地介绍Java平台下的多线程编程核心技术及相关工具。