图灵程序设计丛书 图解Java多线程设计模式
作者：结城浩 著；侯振龙，杨文轩 译
出版时间：2017
内容简介
本书通过具体的Java 程序，以浅显易懂的语言逐一说明了多线程和并发处理中常用的12 种设计模式。内容涉及线程的基础知识、线程的启动与终止、线程间的互斥处理与协作、线程的有效应用、线程的数量管理以及性能优化的注意事项等。此外，还介绍了一些多线程编程时容易出现的失误，以及多线程程序的阅读技巧等。在讲解过程中，不仅以图配文，理论结合实例，而且提供了运用模式解决具体问题的练习题和答案，帮助读者加深对多线程和并发处理的理解，并掌握其使用技巧。
目录
序章1\tJava线程\t1
I1．1\tJava线程\t2
I1．2\t何谓线程\t2
明为跟踪处理流程，实为跟踪线程\t2
单线程程序\t3
多线程程序\t4
Thread类的run方法和start方法\t5
I1．3\t线程的启动\t9
线程的启动（1）——利用Thread类的子类\t9
线程的启动（2）——利用Runnable接口\t10
I1．4\t线程的暂停\t12
I1．5\t线程的互斥处理\t13
synchronized方法\t14
synchronized代码块\t17
I1．6\t线程的协作\t18
等待队列——线程休息室\t19
wait方法——将线程放入等待队列\t19
notify方法——从等待队列中取出线程\t21
notifyAll方法——从等待队列中取出所有线程\t23
wait、notify、notifyAll是Object类的方法\t24
I1．7\t线程的状态迁移\t24
I1．8\t线程相关的其他话题\t26
I1．9\t本章所学知识\t26
I1．10\t练习题\t26
序章2\t多线程程序的评价标准\t31
I2．1\t多线程程序的评价标准\t32
安全性——不损坏对象\t32
生存性——必要的处理能够被执行\t32
可复用性——类可重复利用\t33
性能——能快速、大批量地执行处理\t33
评价标准总结\t33
I2．2\t本章所学知识\t34
I2．3\t练习题\t34
第1章\tSingle Threaded Execution模式——能通过这座桥的只有一个人\t35
1．1\tSingle Threaded Execution模式\t36
1．2\t示例程序1：不使用Single Threaded Execution模式的程序\t36
Main类\t37
非线程安全的Gate类\t37
UserThread类\t38
执行起来看看……出错了\t39
为什么会出错呢\t40
1．3\t示例程序2：使用Single Threaded Execution模式的程序\t41
线程安全的Gate类\t41
synchronized的作用\t42
1．4\tSingle Threaded Execution模式中的登场角色\t43
1．5\t拓展思路的要点\t44
何时使用（可使用Single Threaded Execution模式的情况）\t44
生存性与死锁\t45
可复用性和继承反常\t46
临界区的大小和性能\t46
1．6\t相关的设计模式\t47
Guarded Suspension模式\t47
Read-Write Lock模式\t47
Immutable模式\t47
Thread-Specific Storage模式\t48
1．7\t延伸阅读1：关于synchronized\t48
synchronized语法与Before/After模式\t48
synchronized在保护着什么\t49
该以什么单位来保护呢\t50
使用哪个锁保护\t50
原子操作\t51
long与double的操作不是原子的\t51
1．8\t延伸阅读2：java．util．concurrent包和计数信号量\t52
计数信号量和Semaphore类\t52
使用Semaphore类的示例程序\t52
1．9\t本章所学知识\t55
1．10\t练习题\t55
第2章\tImmutable模式——想破坏也破坏不了\t61
2．1\tImmutable模式\t62
2．2\t示例程序\t62
使用Immutable模式的Person类\t62
Main类\t63
PrintPersonThread类\t63
2．3\tImmutable模式中的登场角色\t65
2．4\t拓展思路的要点\t66
何时使用（可使用Immutable模式的情况）\t66
考虑成对的mutable类和immutable类 [性能]\t66
为了确保不可变性 [可复用性]\t67
标准类库中用到的Immutable模式\t67
2．5\t相关的设计模式\t69
Single Threaded Execution模式\t69
Read-Write Lock模式\t69
Flyweight模式\t69
2．6\t延伸阅读1：final\t69
final的含义\t69
2．7\t延伸阅读2：集合类与多线程\t71
示例1：非线程安全的java．util．ArrayList类\t71
示例2：利用Collections．synchronizedList方法所进行的同步\t74
示例3：使用copy-on-write的java．util．concurrent．CopyOnWriteArrayList类\t75
2．8\t本章所学知识\t76
2．9\t练习题\t77
第3章\tGuarded Suspension模式——等我准备好哦\t81
3．1\tGuarded Suspension模式\t82
3．2\t示例程序\t82
Request类\t83
RequestQueue类\t84
ClientThread类\t85
ServerThread类\t85
Main类\t86
java．util．Queue与java．util．LinkedList的操作\t87
getRequest详解\t87
putRequest详解\t89
synchronized的含义\t89
wait与锁\t89
3．3\tGuarded Suspension模式中的登场角色\t90
3．4\t拓展思路的要点\t91
附加条件的synchronized\t91
多线程版本的if\t91
忘记改变状态与生存性\t91
wait与notify/notifyAll的责任 [可复用性]\t91
各种称呼\t91
使用java．util．concurrent．LinkedBlockingQueue的示例程序\t93
3．5\t相关的设计模式\t94
Single Threaded Execution模式\t94
Balking模式\t94
Producer-Consumer模式\t94
Future模式\t94
3．6\t本章所学知识\t95
3．7\t练习题\t95
第4章\tBalking模式——不需要就算了\t99
4．1\tBalking模式\t100
4．2\t示例程序\t100
Data类\t100
SaverThread类\t102
ChangerThread类\t102
Main类\t103
4．3\tBalking模式中的登场角色\t105
4．4\t拓展思路的要点\t106
何时使用（可使用Balking模式的情况）\t106
balk结果的表示方式\t107
4．5\t相关的设计模式\t107
Guarded Suspension模式\t107
Observer模式\t107
4．6\t延伸阅读：超时\t108
Balking模式和Guarded Suspension模式之间\t108
wait何时终止呢\t108
guarded timed的实现（使用wait）\t109
synchronized中没有超时，也不能中断\t110
java．util．concurrent中的超时\t111
4．7 本章所学知识\t111
4．8 练习题\t112
第5章\tProducer-Consumer模式——我来做，你来用\t115
5．1\tProducer-Consumer模式\t116
5．2\t示例程序\t116
Main类\t116
MakerThread类\t117
EaterThread类\t118
Table类\t118
解读put方法\t120
解读take方法\t121
5．3\tProducer-Consumer模式中的登场角色\t122
5．4\t拓展思路的要点\t123
守护安全性的Channel角色（可复用性）\t123
不可以直接传递吗\t124
Channel角色的剩余空间所导致的问题\t124
以什么顺序传递Data角色呢\t125
“存在中间角色”的意义\t125
Consumer角色只有一个时会怎么样呢\t126
5．5\t相关的设计模式\t126
Mediator模式\t126
Worker Thread模式\t126
Command模式\t126
Strategy模式\t127
5．6\t延伸阅读1：理解InterruptedException异常\t127
可能会花费时间，但可以取消\t127
加了throws InterruptedException的方法\t127
sleep方法和interrupt方法\t128
wait方法和interrupt方法\t128
join方法和interrupt方法\t129
interrupt方法只是改变中断状态\t129
isInterrupted方法——检查中断状态\t130
Thread．interrupted方法——检查并清除中断状态\t130
不可以使用Thread类的stop方法\t130
5．7\t延伸阅读2：java．util．concurrent包和Producer-Consumer模式\t131
java．util．concurrent包中的队列\t131
使用java．util．concurrent．ArrayBlockingQueue的示例程序\t132
使用java．util．concurrent．Exchanger类交换缓冲区\t133
5．8\t本章所学知识\t136
5．9\t练习题\t137
第6章\tRead-Write Lock模式——大家一起读没问题，但读的时候不要写哦\t141
6．1\tRead-Write Lock模式\t142
6．2\t示例程序\t142
Main类\t143
Data类\t143
WriterThread类\t146
ReaderThread类\t146
ReadWriteLock类\t147
执行起来看看\t149
守护条件的确认\t150
6．3\tRead-Write Lock模式中的登场角色\t151
6．4\t拓展思路的要点\t153
利用“读取”操作的线程之间不会冲突的特性来提高程序性能\t153
适合读取操作繁重时\t153
适合读取频率比写入频率高时\t153
锁的含义\t153
6．5\t相关的设计模式\t154
Immutable模式\t154
Single Threaded Execution模式\t154
Guarded Suspension模式\t154
Before/After模式\t154
Strategized Locking模式\t154
6．6\t延伸阅读：java．util．concurrent．locks包和Read-Write Lock模式\t154
java．util．concurrent．locks包\t154
使用java．util．concurrent．locks的示例程序\t155
6．7\t本章所学知识\t156
6．8\t练习题\t157
第7章\tThread-Per-Message模式——这项工作就交给你了\t163
7．1\tThread-Per-Message模式\t164
7．2\t示例程序\t164
Main类\t164
Host类\t165
Helper类\t166
7．3\tThread-Per-Message模式中的登场角色\t168
7．4\t拓展思路的要点\t169
提高响应性，缩短延迟时间\t169
适用于操作顺序没有要求时\t169
适用于不需要返回值时\t169
应用于服务器\t169
调用方法＋启动线程→发送消息\t170
7．5\t相关的设计模式\t170
Future模式\t170
Worker Thread模式\t170
7．6\t延伸阅读1：进程与线程\t171
7．7\t延伸阅读2：java．util．concurrent包和Thread-Per-Message模式\t171
java．lang．Thread类\t171
java．lang．Runnable接口\t172
java．util．concurrent．ThreadFactory接口\t173
java．util．concurrent．Executors类获取的ThreadFactory\t174
java．util．concurrent．Executor接口\t175
java．util．concurrent．ExecutorService接口\t176
java．util．concurrent．ScheduledExecutorService类\t177
总结\t178
7．8\t本章所学知识\t180
7．9\t练习题\t180
第8章\tWorker Thread模式——工作没来就一直等，工作来了就干活\t187
8．1\tWorker Thread模式\t188
8．2\t示例程序\t188
Main类\t189
ClientThread类\t190
Request类\t190
Channel类\t191
WorkerThread类\t192
8．3\tWorker Thread模式中的登场角色\t193
8．4\t拓展思路的要点\t195
提高吞吐量\t195
容量控制\t195
调用与执行的分离\t196
Runnable接口的意义\t197
多态的Request角色\t198
独自一人的Worker角色\t199
8．5\t相关的设计模式\t199
Producer-Consumer模式\t199
Thread-Per-Message模式\t199
Command模式\t199
Future模式\t199
Flyweight模式\t199
Thread-Specific Storage模式\t200
Active Ojbect模式\t200
8．6\t延伸阅读1：Swing事件分发线程\t200
什么是事件分发线程\t200
事件分发线程只有一个\t200
事件分发线程调用监听器\t201
注册监听器的意义\t201
事件分发线程也负责绘制界面\t201
javax．swing．SwingUtilities类\t202
Swing的单线程规则\t203
8．7\t延伸阅读2：java．util．concurrent包和Worker Thread模式\t204
ThreadPoolExecutor类\t204
通过java．util．concurrent包创建线程池\t205
8．8\t本章所学知识\t207
8．9\t练习题\t208
第9章\tFuture模式——先给您提货单\t211
9．1\tFuture模式\t212
9．2\t示例程序\t212
Main类\t214
Host类\t214
Data接口\t215
FutureData类\t216
RealData类\t217
9．3\tFuture模式中的登场角色\t218
9．4\t拓展思路的要点\t219
吞吐量会提高吗\t219
异步方法调用的“返回值”\t220
“准备返回值”和“使用返回值”的分离\t220
变种——不让主线程久等的Future角色\t220
变种——会发生变化的Future角色\t221
谁会在意多线程呢？“可复用性”\t221
回调与Future模式\t221
9．5\t相关的设计模式\t222
Thread-Per-Message模式\t222
Builder模式\t222
Proxy模式\t222
Guarded Suspension模式\t222
Balking模式\t222
9．6\t延伸阅读：java．util．concurrent包与Future模式\t222
java．util．concurrent包\t222
使用了java．util．concurrent包的示例程序\t223
9．7\t本章所学知识\t226
9．8\t练习题\t226
第10章\tTwo-Phase Termination模式——先收拾房间再睡觉\t231
10．1\tTwo-Phase Termination模式\t232
10．2\t示例程序\t233
CountupThread类\t234
Main类\t236
10．3\tTwo-Phase Termination模式中的登场角色\t237
10．4\t拓展思路的要点\t238
不能使用Thread类的stop方法\t238
仅仅检查标志是不够的\t239
仅仅检查中断状态是不够的\t239
在长时间处理前检查终止请求\t239
join方法和isAlive方法\t240
java．util．concurrent．ExecutorService接口与Two-Phase Termination模式\t240
要捕获程序整体的终止时\t241
优雅地终止线程\t243
10．5\t相关的设计模式\t243
Before/After模式\t243
Multiphase Cancellation模式\t243
Multi-Phase Startup模式\t244
Balking模式\t244
10．6\t延伸阅读1：中断状态与InterruptedException异常的相互转换\t244
中断状态→InterruptedException异常的转换\t244
InterruptedException异常→中断状态的转换\t245
InterruptedException异常→InterruptedException异常的转换\t245
10．7\t延伸阅读2：java．util．concurrent包与线程同步\t246
java．util．concurrent．CountDownLatch类\t246
java．util．concurrent．CyclicBarrier类\t249
10．8\t本章所学知识\t253
10．9\t练习题\t253
第11章\tThread-Specific Storage模式——一个线程一个储物柜\t263
11．1\tThread-Specific Storage模式\t264
11．2\t关于java．lang．ThreadLocal类\t264
java．lang．ThreadLocal就是储物间\t264
java．lang．ThreadLocal与泛型\t265
11．3\t示例程序1：不使用Thread-Specific Storage模式的示例\t265
Log类\t266
Main类\t266
11．4\t示例程序2：使用了Thread-Specific Storage模式的示例\t267
线程特有的TSLog类\t268
Log类\t269
ClientThread类\t270
Main类\t271
11．5\tThread-Specific Storage模式中的登场角色\t272
11．6\t拓展思路的要点\t274
局部变量与java．lang．ThreadLocal类\t274
保存线程特有的信息的位置\t275
不必担心其他线程访问\t275
吞吐量的提高很大程序上取决于实现方式\t276
上下文的危险性\t276
11．7\t相关的设计模式\t277
Singleton模式\t277
Worker Thread模式\t277
Single Threaded Execution模式\t277
Proxy模式\t277
11．8 延伸阅读：基于角色与基于任务\t277
主体与客体\t277
基于角色的考虑方式\t278
基于任务的考虑方式\t278
实际上两种方式是综合在一起的\t279
11．9\t本章所学知识\t279
11．10\t练习题\t280
第12章\tActive Object模式——接收异步消息的主动对象\t283
12．1\tActive Object模式\t284
12．2\t示例程序1\t284
调用方：Main类\t287
调用方：MakerClientThread类\t288
调用方：DisplayClientThread类\t289
主动对象方：ActiveObject接口\t289
主动对象方：ActiveObjectFactory类\t290
主动对象方：Proxy类\t290
主动对象方：SchedulerThread类\t291
主动对象方：ActivationQueue类\t292
主动对象方：MethodRequest类\t293
主动对象方：MakeStringRequest类\t294
主动对象方：DisplayStringRequest类\t295
主动对象方：Result类\t295
主动对象方：FutureResult类\t296
主动对象方：RealResult类\t296
主动对象方：Servant类\t297
示例程序1的运行\t297
12．3\tActiveObject模式中的登场角色\t298
12．4\t拓展思路的要点\t304
到底做了些什么事情\t304
运用模式时需要考虑问题的粒度\t304
关于并发性\t304
增加方法\t305
Scheduler角色的作用\t305
主动对象之间的交互\t306
通往分布式——从跨越线程界线变为跨越计算机界线\t306
12．5\t相关的设计模式\t306
Producer-Consumer模式\t306
Future模式\t307
Worker Thread模式\t307
Thread-Specific Storage模式\t307
12．6\t延伸阅读：java．util．concurrent包与Active Object模式\t307
类与接口\t307
调用方：Main类\t309
调用方：MakerClientThread类\t309
调用方：DisplayClientThread类\t310
主动对象方：ActiveObject接口\t311
主动对象方：ActiveObjectFactory类\t311
主动对象：ActiveObjectImpl类\t312
示例程序2的运行\t313
12．7\t本章所学知识\t314
12．8\t练习题\t315
第13章\t总结——多线程编程的模式语言\t321
13．1\t多线程编程的模式语言\t322
模式与模式语言\t322
13．2\tSingle Threaded Execution模式
\t——能通过这座桥的只有一个人\t323
13．3 Immutable模式
\t——想破坏也破坏不了\t324
13．4 Guarded Suspension模式
\t——等我准备好哦\t325
13．5 Balking模式
\t——不需要就算了\t326
13．6 Producer-Consumer模式
\t——我来做，你来用\t327
13．7 Read-Write Lock模式
\t——大家一起读没问题，但读的时候不要写哦\t328
13．8 Thread-Per-Message模式
\t——这项工作就交给你了\t329
13．9 Worker Thread模式
\t——工作没来就一直等，工作来了就干活\t330
13．10\tFuture模式
\t——先给您提货单\t330
13．11\tTwo-Phase Termination模式
\t——先收拾房间再睡觉\t331
13．12\tThread-Specific Storage模式
\t——一个线程一个储物柜\t332
13．13\tActive Object模式
\t——接收异步消息的主动对象\t333
13．14\t写在最后\t335
附录\t\t337
附录A 习题解答\t338
附录B Java内存模型\t447
附录C Java线程的优先级\t467
附录D 线程相关的主要API\t469
附录E java．util．concurrent包\t475
附录F 示例程序的运行步骤\t483
附录G 参考文献\t485
