Java多线程设计模式PDF电子书下载

漫谈UML 1

UML 2

类图 2

类和层次结构的关系 2

接口与实现 3

聚合 4

访问控制 5

类间的关联性 5

顺序图 6

处理流程和对象间的协调 6

时序图 7

Introduction 1 Java语言的线程 9

Java语言的线程 10

何谓线程 10

明为追踪处理流程，实则追踪线程 10

单线程程序 11

多线程程序 12

Thread类的run方法和start方法 13

线程的启动 17

线程的启动（1）——利用Thread类的子类 17

线程的启动（2）——利用Runnable接口 19

线程的暂时停止 21

线程的共享互斥 22

synchronized方法 23

synchronized阻挡 27

线程的协调 28

wait set——线程的休息室 29

wait方法——把线程放入wait set 29

notify方法——从wait set拿出线程 31

notifyAll方法——从wait set拿出所有线程 33

wait、notify、notifyAll是Object类的方法 34

线程的状态移转 35

跟线程有关的其他话题 36

重点回顾 36

练习问题 37

Introduction 2 多线程程序的评量标准 41

多线程程序的评量标准 42

安全性——不损坏对象 42

生存性——进行必要的处理 42

复用性——可再利用类 43

性能——能快速、大量进行处理 43

评量标准的总结 44

重点回顾 44

练习问题 44

第1章 Single Threaded Execution——能通过这座桥的，只有一个人 47

Single Threaded Execution Pattern 48

范例程序1：不使用Single Threaded Execution Pattern的范例 48

并非线程安全（thread-safe）的Gate类 49

Main类 49

UserThread类 51

执行看看……果然出错了 51

为什么会出错呢 53

范例程序2：使用Single Threaded Execution Pattern的范例 54

线程安全的Gate类 55

synchronized所扮演的角色 55

Single Threaded Execution Patttern的所有参与者 57

扩展思考方向的提示 58

何时使用（适用性） 58

生命性与死锁 59

临界区的大小与执行性能 60

可重用性与继承异常 60

相关Pattern 61

Guarded Suspension Pattern（第3章） 61

Read-Write Lock Pattern（第6章） 61

Immutable Pattern（第2章） 61

Thread-Specific Storage Pattern（第11章） 62

进阶说明：关于synchronized 62

synchronized语法与Before/AfterPattern 62

这个synchronized在保护什么 64

该以什么单位来保护呢 64

原子的操作 65

long与double并不是原子的 65

获取谁的锁定来保护的呢 65

重点回顾 67

练习问题 67

第2章 Immutable——想破坏它也没办法 75

Immutable Pattern 76

范例程序 76

使用Immutable Pattern的Person类 76

Main类 77

PrintPersonThread类 78

Immutable Pattern的所有参与者 80

何时使用（适用性） 81

思考成对的mutable类与immutable类［执行性能］ 81

扩展思考方向的提示 81

为了保护类的不变性［复用性］ 82

标准类链接库里使用到的Immutable Pattern 83

相关Pattern 84

Single Threaded Execution Pattern（第1章） 84

Read-Write Lock Pattern（第6章） 84

Flyweight Pattern（参考附录E［GoF］［Yuki01］） 84

进阶说明：final 85

重点回顾 86

练习问题 86

第3章 Guarded Suspension——要等到我准备好喔 93

Guarded Suspension Pattern 94

范例程序 94

Request类 95

RequestQueue类 96

ClientThread类 97

ServerThread类 98

Main类 99

java.util.LinkedList类的操作 100

仔细分析getRequest方法 100

仔细分析putRequest方法 102

synchronized的意义 102

wait与锁定 103

Guarded SuspensionPattern的所有参与者 103

多线程版的if 104

有条件的synchronized 104

扩展思考方向的提示 104

忘记更改状态与生命性 105

wait与notify/notifyAll的责任［复用性］ 105

各种各样的称呼 105

相关Pattern 107

Single Threaded Execution Pattern（第1章） 107

Balking Pattern（第4章） 107

Producer-Consumer Pattern（第5章） 107

Future Pattern（第9章） 107

重点回顾 107

练习问题 108

第4章 Balking——不需要的话，就算了吧 115

范例程序 116

Balking Pattern 116

Data类 117

SaverThread类 119

ChangerThread类 119

Main类 120

Balking Pattern的所有参与者 122

扩展思考方向的提示 123

何时使用（适用性） 123

表达balk结果的方式 124

进阶说明：timeout 125

wait的结束是什么时候 125

Balking Pattern与Guarded Suspension Pattern的中间 125

Guarded Suspension Pattern（第3章） 125

Observer Pattern（参考附录E［GoF］［Yuki01］） 125

相关Pattern 125

guarded timed的实现 126

synchronized没有timeout，也不能中断 129

重点回顾 129

练习问题 130

第5章 Producer-Consumer——我来做，你来用 135

Producer-Consumer Pattern 136

范例程序 136

MakerThread类 137

Main类 137

EaterThread类 138

Table类 139

分析put方法 141

分析take方法 142

Producer-ConsumerPattern的所有参与者 144

扩展思考方向的提示 145

保护安全性的Channel参与者［复用性］ 145

不能直接传递吗 145

Channel参与者负荷派生的问题 146

要以什么顺序传递Data参与者 146

［中间者的存在］隐含的意义 147

只有一个Consumer参与者时会如何 148

相关Pattern 148

Mediator Pattern（参考附录E［GoF］［Yuki01］） 148

Worker Thread Pattern（第8章） 149

CommandPattern（参考附录E［GoF］［Yuki01］） 149

Strategy Pattern（参考附录E［GoF］［Yuki01］） 149

进阶说明：InterruptedException异常 149

可能会花一些时间，但是可以取消掉 149

后面接着throws InterruptedException的方法 149

sleep方法与interrupt方法 150

join方法与interrupt方法 151

interrupt方法只是改变中断状态而已 151

wait方法与interrupt方法 151

isInterrupted方法——检查中断状态 152

Thread.interrupted方法——检查并清除中断状态 153

Thread类的stop方法不能使用 153

重点回顾 153

练习问题 154

第6章 Read-Write Lock——大家想看就看吧，不过看的时候不能写喔 159

Read-Write Lock Pattern 160

范例程序 160

Main类 161

Data类 161

WriterThread类 164

ReaderThread类 165

ReadWriteLock类 166

执行结果 169

检验警戒条件 170

Read-Write Lock Pattern的所有参与者 171

扩展思考方向的提示 172

利用同时“读取”不会冲突的特性，提高程序的性能 172

适合读取操作繁重时 172

适合读取比写入次数频繁时 173

锁定的意义 173

相关Pattern 173

Immutable Pattern（第2章）。 173

重点回顾 174

Strategized Locking Pattern（参考附录E［POSA2］） 174

Single Threaded Execution Pattern（第1章） 174

Guarded Suspension Pattern（第3章） 174

Before/After Pattern（参考附录E［Lea］） 174

练习问题 175

第7章 Thread-Per-Message——这个工作交给你了 181

Thread-Per-Message Pattern 182

范例程序 182

Main类 183

Host类 183

Helper类 184

Thread-Per-Message Pattern的所有参与者 187

提升响应性，降低延迟时间 188

扩展思考方向的提示 188

适合在操作顺序无所谓时使用 189

不需要返回值的时候 189

应用在服务器的制作 189

调用方法＋启动线程→传送消息 189

相关Pattern 190

Future Pattern（第9章） 190

Worker Thread Pattern（第8章） 190

进阶说明：进程与线程 190

重点回顾 191

练习问题 192

第8章 Worker Thread——等到工作来，来了就工作 199

范例程序 200

Worker Thread Pattern 200

Main类 202

ClientThread类 202

Request类 203

Channel类 204

WorkerThread类 205

Worker Thread Pattern的所有参与者 207

启动线程是繁重的操作 209

控制承载量 209

扩展思考方向的提示 209

invocation与execution的分离 210

Runnable接口的意义 211

多态的Request参与者 211

只有一条Worker参与者 212

相关Pattern 213

Producer-ConsumerPattern（第5章） 213

Thread-Per-Message Pattern（第7章） 213

Command Pattern（参考附录E［GoF］［Yuki01］） 213

Future Pattern（第9章） 213

Flyweight Pattern（参考附录E［GoF］［Yuki01］） 213

何谓Event-Dispatching Thread 214

进阶说明：Swing的Event-Dispatching Thread 214

Thread-Specific Storage Pattern（第11章） 214

Active Object Pattern（第12章） 214

Event-dispatching thread只有一条 215

Event-dispatching thread会调用Listener 215

注册Listener的意义 217

Event-dispatching thread也处理画面的重绘 217

javax.swing.SwingUtilities类 217

Swing的单线程规则 218

重点回顾 219

练习问题 219

第9章 Future——先给您这张提货单 225

范例程序 226

Future Pattern 226

Main类 228

Host类 229

Data接口 231

FutureData类 231

RealData类 232

Future Pattern的所有参与者 234

扩展思考方向的提示 236

能够提升throughput吗 236

异步方法调用的“返回值” 236

变形——会改变的Future参与者 237

变形——不让人等待的Future参与者 237

分离“准备返回值”与“使用返回值” 237

谁需要考虑到多线程［复用性］ 238

回调与Future Pattern 238

相关Pattern 239

Thread-Per-Message Pattern（第7章） 239

Builder Pattern（参考附录E［GoF］［Yuki01］） 239

Proxy Pattern（参考附录E［GoF］［Yuki01］） 239

Guarded Suspension Pattern（第3章） 239

重点回顾 239

练习问题 240

第10章 Two-Phase Termination——快把玩具收拾好，去睡觉吧 247

Two-Phase Termination Pattern 248

范例程序 249

CountupThread类 250

Main类 252

Two-Phase Termination Pattern的所有参与者 254

扩展思考方向的提示 255

不可以使用Thread类的stop方法 255

只检查标识是不够周全的 256

只测试中断状态也是不够的 256

进行繁重的处理前，先检查终止请求 257

join方法与isAlive方法 257

程序的结束与addShutdownHook方法 257

Multiphase Cancellation Pattern（参考附录E［Lea］） 259

Before/After Pattern（参考附录E［Lea］） 259

优雅终止的线程 259

相关Pattern 259

Multi-Phase StartupPattern 260

Balking Pattern（第4章） 260

进阶说明：中断状态与InterruptedException异常的相互转换 260

中断状态→InterruptedException异常的转换 260

InterruptedException异常→转换为中断状态 261

InterruptedException异常→转换为InterruptedException异常 262

重点回顾 262

练习问题 263

第11章 Thread-Specific Storage——每个线程的保管箱 273

java.lang.ThreadLocal是保管箱间 274

Thread-Specific StoragePattern 274

关于java.lang.ThreadLocal类 274

范例程序1：没有使用Thread-Specific Storage Pattern的范例 275

Log类 276

Main类 277

范例程序2：使用Thread-Specific Storage Pattern的范例 278

线程特有的TSLog类 278

Log类 280

ClientThread类 281

Main类 282

Thread-Specific Storage Pattern的所有参与者 283

局部变量与java.lang.ThreadLocal类 286

扩展思考方向的提示 286

放置线程特有信息的地方 287

不必担心被其他线程访问 288

throughput的提升取决于实现 288

隐藏context的危险性 289

相关Pattern 289

Singleton Pattern（参考附录E［GoF］［Yuki01］） 289

WorkerThread Pattern（第8章） 290

Single Threaded Execution Pattern（第1章） 290

Proxy Pattern（参考附录E［GoF］［Yuki01］） 290

进阶说明：Actor-based与Task-based 290

主体与客体 290

Task-based的思维 291

Actor-based的思维 291

实际上两个开发方式是混用的 292

重点回顾 292

练习问题 293

第12章 Active Object——接受异步消息的主动对象 295

Active Object Pattern 296

范例程序 296

使用端：Main类 298

使用端：MakerClientThread类 299

使用端：DisplayClientThread类 300

“主动对象”端：ActiveObject接口 300

“主动对象”端：ActiveObjectFactory类 301

“主动对象”端：Proxy类 302

“主动对象”端：SchedulerThread类 303

“主动对象”端：ActivationQueue类 304

“主动对象”端：MethodRequest类 305

“主动对象”端：MakeStringRequest类 306

“主动对象”端：DisplayStringRequest类 307

“主动对象”端：Result类 307

“主动对象”端：FutureResult类 308

“主动对象”端：RealResult类 309

“主动对象”端：Servant类 309

执行范例程序 310

Active ObjectPattern的所有参与者 311

扩展思考方向的提示 314

到底做了什么事呢 314

Pattern是否适合使用要考虑问题的规模 316

注意并发性 317

新增方法 317

Scheduler参与者的角色 318

“主动对象”之间的对话 318

迈向分布处理——将线程的界限移到机器的界限 318

重点回顾 319

Thread-Specific Storage Pattern（第11章） 319

Worker Thread Pattern（第8章） 319

Future Pattern（第9章） 319

Producer-Consumer Pattern（第5章） 319

相关Pattern 319

练习问题 320

总结 多线程程序设计的模式语言 325

多线程程序设计的模式语言 326

Pattern与Pattern Language 326

Single Threaded Execution Pattern（第1章）——能通过这座桥的，只有一个人 327

Immutable Pattern（第2章）——想破坏它也没办法 328

Guarded Suspension Pattern（第3章）——等到我准备好 329

Balking Pattern（第4章）——不需要的话，就算了吧 330

Producer-Consumer Pattern（第5章）——你来做，我来用 331

Read-Write Lock Pattern（第6章）——大家想看就看吧，不过看的时候不能写喔 332

Thread-Per-Message Pattern（第7章）——这个工作交给你了 334

Worker Thread Pattern（第8章）——等到工作来，来了就工作 334

Future Pattern（第9章）——先给您这张提货单 335

Two-Phase Termination Pattern（第10章）——快把玩具收拾好，去睡觉吧 336

Thread-Specific Storage Pattern（第11章）——每个线程的保管箱 337

Active Object Pattern（第12章）——接受异步消息的主动对象 339

尾声 340

附录A 练习问题的解答 341

附录B Java的内存模型 461

附录C Java线程的优先级 475

附录D 线程相关的主要API 479

附录E 参考文献 487