轻松学习多线程编程 图解Java多线程设计模式结城浩Java线程书籍多线程编程技巧【2025|PDF|Epub|mobi|kindle电子书版本百度云盘下载】

轻松学习多线程编程 图解Java多线程设计模式结城浩Java线程书籍多线程编程技巧PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

序章1 Java线程1

1.1 Java线程2

1.2 何谓线程2

明为跟踪处理流程，实为跟踪线程2

单线程程序3

多线程程序4

Thread类的run方法和start方法5

1.3 线程的启动9

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

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

1.4 线程的暂停12

1.5 线程的互斥处理13

synchronized方法14

synchronized代码块17

1.6 线程的协作18

等待队列——线程休息室19

wait方法——将线程放入等待队列19

notify方法——从等待队列中取出线程21

notifyAll方法——从等待队列中取出所有线程23

wait、notify、notify All是Object类的方法24

1.7 线程的状态迁移24

1.8 线程相关的其他话题26

1.9 本章所学知识26

1.10 练习题26

序章2 多线程程序的评价标准31

2.1 多线程程序的评价标准32

安全性——不损坏对象32

生存性——必要的处理能够被执行32

可复用性——类可重复利用33

性能——能快速、大批量地执行处理33

评价标准总结33

2.2 本章所学知识34

2.3 练习题34

第1章 Single Threaded Execution模式——能通过这座桥的只有一个人35

1.1 Single Threaded Execution模式36

1.2 示例程序1：不使用Single Threaded Execution模式的程序36

Main类37

非线程安全的Gate类37

UserThread类38

执行起来看看……出错了39

为什么会出错呢40

1.3 示例程序2：使用Single Threaded Execution模式的程序41

线程安全的Gate类41

synchronized的作用42

1.4 Single Threaded Execution模式中的登场角色43

1.5 拓展思路的要点44

何时使用（可使用Single Threaded Execution模式的情况）44

生存性与死锁45

可复用性和继承反常46

临界区的大小和性能46

1.6 相关的设计模式47

Guarded Suspension模式47

Read-Write Lock模式47

Immutable模式47

Thread-Specific Storage模式48

1.7 延伸阅读1：关于synchronized48

synchronized语法与Before/After模式48

synchronized在保护着什么49

该以什么单位来保护呢50

使用哪个锁保护50

原子操作51

long与double的操作不是原子的51

1.8 延伸阅读2：java.util.concurrent包和计数信号量52

计数信号量和Semaphore类52

使用Semaphore类的示例程序52

1.9 本章所学知识55

1.10 练习题55

第2章 Immutable模式——想破坏也破坏不了61

2.1 Immutable模式62

2.2 示例程序62

使用Immutable模式的Person类62

Main类63

PrintPersonThread类63

2.3 Immutable模式中的登场角色65

2.4 拓展思路的要点66

何时使用（可使用Immutable模式的情况）66

考虑成对的mutable类和immutable类［性能］66

为了确保不可变性［可复用性］67

标准类库中用到的Immutable模式67

2.5 相关的设计模式69

Single Threaded Execution模式69

Read-Write Lock模式69

Flyweight模式69

2.6 延伸阅读1：final69

final的含义69

2.7 延伸阅读2：集合类与多线程71

示例1：非线程安全的java.util.ArrayList类71

示例2：利用Collections.synchronizedList方法所进行的同步74

示例3：使用copy-on-write的java.util.concurrent.CopyOnWriteArrayList类75

2.8 本章所学知识76

2.9 练习题77

第3章 Guarded Suspension模式——等我准备好哦81

3.1 Guarded Suspension模式82

3.2 示例程序82

Request类83

RequestQueue类84

ClientThread类85

ServerThread类85

Main类86

java.util.Queue与java.util.LinkedList的操作87

getRequest详解87

putRequest详解89

synchronized的含义89

wait与锁89

3.3 Guarded Suspension模式中的登场角色90

3.4 拓展思路的要点91

附加条件的synchronized91

多线程版本的if91

忘记改变状态与生存性91

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

各种称呼91

使用java.util.concurrent.LinkedBlockingQueue的示例程序93

3.5 相关的设计模式94

Single Threaded Execution模式94

Balking模式94

Producer-Consumer模式94

Future模式94

3.6 本章所学知识95

3.7 练习题95

第4章 Balking模式——不需要就算了99

4.1 Balking模式100

4.2 示例程序100

Data类100

SaverThread类102

ChangerThread类102

Main类103

4.3 Balking模式中的登场角色105

4.4 拓展思路的要点106

何时使用（可使用Balking模式的情况）106

balk结果的表示方式107

4.5 相关的设计模式107

Guarded Suspension模式107

Observer模式107

4.6 延伸阅读：超时108

Balking模式和Guarded Suspension模式之间108

wait何时终止呢108

guarded timed的实现（使用wait）109

synchronized中没有超时，也不能中断110

java.util.concurrent中的超时111

4.7 本章所学知识111

4.8 练习题112

第5章 Producer-Consumer模式——我来做，你来用115

5.1 Producer-Consumer模式116

5.2 示例程序116

Main类116

MakerThread类117

EaterThread类118

Table类118

解读put方法120

解读take方法121

5.3 Producer-Consumer模式中的登场角色122

5.4 拓展思路的要点123

守护安全性的Channel角色（可复用性）123

不可以直接传递吗124

Channel角色的剩余空间所导致的问题124

以什么顺序传递Data角色呢125

“存在中间角色”的意义125

Consumer角色只有一个时会怎么样呢126

5.5 相关的设计模式126

Mediator模式126

Worker Thread模式126

Command模式126

Strategy模式127

5.6 延伸阅读1：理解InterruptedException异常127

可能会花费时间，但可以取消127

加了throws InterruptedException的方法127

sleep方法和interrupt方法128

wait方法和interrupt方法128

join方法和interrupt方法129

interrupt方法只是改变中断状态129

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

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

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

5.7 延伸阅读2：java.util.concurrent包和Producer-Consumer模式131

java.util.concurrent包中的队列131

使用java.util.concurrent.ArrayBlockingQueue的示例程序132

使用java.util.concurrent.Exchanger类交换缓冲区133

5.8 本章所学知识136

5.9 练习题137

第6章 Read-Write Lock模式——大家一起读没问题，但读的时候不要写哦141

6.1 Read-Write Lock模式142

6.2 示例程序142

Main类143

Data类143

WriterThread类146

ReaderThread类146

ReadWriteLock类147

执行起来看看149

守护条件的确认150

6.3 Read-Write Lock模式中的登场角色151

6.4 拓展思路的要点153

利用“读取”操作的线程之间不会冲突的特性来提高程序性能153

适合读取操作繁重时153

适合读取频率比写入频率高时153

锁的含义153

6.5 相关的设计模式154

Immutable模式154

Single Threaded Execution模式154

Guarded Suspension模式154

Before/After模式154

Strategized Locking模式154

6.6 延伸阅读：java.util.concurrent.locks包和Read-Write Lock模式154

java.util.concurrent.locks包154

使用java.util.concurrent.locks的示例程序155

6.7 本章所学知识156

6.8 练习题157

第7章 Thread-Per-Message模式——这项工作就交给你了163

7.1 Thread-Per-Message模式164

7.2 示例程序164

Main类164

Host类165

Helper类166

7.3 Thread-Per-Message模式中的登场角色168

7.4 拓展思路的要点169

提高响应性，缩短延迟时间169

适用于操作顺序没有要求时169

适用于不需要返回值时169

应用于服务器169

调用方法＋启动线程→发送消息170

7.5 相关的设计模式170

Future模式170

Worker Thread模式170

7.6 延伸阅读1：进程与线程171

7.7 延伸阅读2：java.util.concurrent包和Thread-Per-Message模式171

java.lang.Thread类171

java.lang.Runnable接口172

java.util.concurrent.ThreadFactory接口173

java.util.concurrent.Executors类获取的ThreadFactory174

java.util.concurrent.Executor接口175

java.util.concurrent.ExecutorService接口176

java.util.concurrent.ScheduledExecutorService类177

总结178

7.8 本章所学知识180

7.9 练习题180

第8章 Worker Thread模式——工作没来就一直等，工作来了就干活187

8.1 Worker Thread模式188

8.2 示例程序188

Main类189

ClientThread类190

Request类190

Channel类191

WorkerThread类192

8.3 Worker Thread模式中的登场角色193

8.4 拓展思路的要点195

提高吞吐量195

容量控制195

调用与执行的分离196

Runnable接口的意义197

多态的Request角色198

独自一人的Worker角色199

8.5 相关的设计模式199

Producer-Consumer模式199

Thread-Per-Message模式199

Command模式199

Future模式199

Flyweight模式199

Thread-Specific Storage模式200

Active Ojbect模式200

8.6 延伸阅读1：Swing事件分发线程200

什么是事件分发线程200

事件分发线程只有一个200

事件分发线程调用监听器201

注册监听器的意义201

事件分发线程也负责绘制界面201

javax.swing.SwingUtilities类202

Swing的单线程规则203

8.7 延伸阅读2：java.util.concurrent包和Worker Thread模式204

ThreadPoolExecutor类204

通过java.util.concurrent包创建线程池205

8.8 本章所学知识207

8.9 练习题208

第9章 Future模式——先给您提货单211

9.1 Future模式212

9.2 示例程序212

Main类214

Host类214

Data接口215

FutureData类216

RealData类217

9.3 Future模式中的登场角色218

9.4 拓展思路的要点219

吞吐量会提高吗219

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

“准备返回值”和“使用返回值”的分离220

变种——不让主线程久等的Future角色220

变种——会发生变化的Future角色221

谁会在意多线程呢？“可复用性”221

回调与Future模式221

9.5 相关的设计模式222

Thread-Per-Message模式222

Builder模式222

Proxy模式222

Guarded Suspension模式222

Balking模式222

9.6 延伸阅读：java.util.concurrent包与Future模式222

java.util.concurrent包222

使用了java.util.concurrent包的示例程序223

9.7 本章所学知识226

9.8 练习题226

第10章 Two-Phase Termination模式——先收拾房间再睡觉231

10.1 Two-Phase Termination模式232

10.2 示例程序233

CountupThread类234

Main类236

10.3 Two-Phase Termination模式中的登场角色237

10.4 拓展思路的要点238

不能使用Thread类的stop方法238

仅仅检查标志是不够的239

仅仅检查中断状态是不够的239

在长时间处理前检查终止请求239

join方法和isAlive方法240

java.util.concurrent.ExecutorService接口与Two-Phase Termination模式240

要捕获程序整体的终止时241

优雅地终止线程243

10.5 相关的设计模式243

Before/After模式243

Multiphase Cancellation模式243

Multi-Phase Startup模式244

Balking模式244

10.6 延伸阅读1：中断状态与InterruptedException异常的相互转换244

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

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

InterruptedException异常→InterruptedException异常的转换245

10.7 延伸阅读2：java.util.concurrent包与线程同步246

java.util.concurrent.CountDownLatch类246

java.util.concurrent.CyclicBarrier类249

10.8 本章所学知识253

10.9 练习题253

第11章 Thread-Specific Storage模式——一个线程一个储物柜263

11.1 Thread-Specific Storage模式264

11.2 关于java.lang.ThreadLocal类264

java.lang.ThreadLocal就是储物间264

java.lang.ThreadLocal与泛型265

11.3 示例程序1：不使用Thread-Specific Storage模式的示例265

Log类266

Main类266

11.4 示例程序2：使用了Thread-Specific Storage模式的示例267

线程特有的TSLog类268

Log类269

ClientThread类270

Main类271

11.5 Thread-Specific Storage模式中的登场角色272

11.6 拓展思路的要点274

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

保存线程特有的信息的位置275

不必担心其他线程访问275

吞吐量的提高很大程序上取决于实现方式276

上下文的危险性276

11.7 相关的设计模式277

Singleton模式277

Worker Thread模式277

Single Threaded Execution模式277

Proxy模式277

11.8 延伸阅读：基于角色与基于任务277

主体与客体277

基于角色的考虑方式278

基于任务的考虑方式278

实际上两种方式是综合在一起的279

11.9 本章所学知识279

11.10 练习题280

第12章 Active Object模式——接收异步消息的主动对象283

12.1 Active Object模式284

12.2 示例程序1284

调用方：Main类287

调用方：MakerClientThread类288

调用方：DisplayClientThread类289

主动对象方：ActiveObject接口289

主动对象方：ActiveObjectFactory类290

主动对象方：Proxy类290

主动对象方：SchedulerThread类291

主动对象方：ActivationQueue类292

主动对象方：MethodRequest类293

主动对象方：MakeStringRequest类294

主动对象方：DisplayStringRequest类295

主动对象方：Result类295

主动对象方：FutureResult类296

主动对象方：RealResult类296

主动对象方：Servant类297

示例程序1的运行297

12.3 ActiveObject模式中的登场角色298

12.4 拓展思路的要点304

到底做了些什么事情304

运用模式时需要考虑问题的粒度304

关于并发性304

增加方法305

Scheduler角色的作用305

主动对象之间的交互306

通往分布式——从跨越线程界线变为跨越计算机界线306

12.5 相关的设计模式306

Producer-Consumer模式306

Future模式307

Worker Thread模式307

Thread-Specific Storage模式307

12.6 延伸阅读：java.util.concurrent包与Active Object模式307

类与接口307

调用方：Main类309

调用方：MakerClientThread类309

调用方：DisplayClientThread类310

主动对象方：ActiveObject接口311

主动对象方：ActiveObjectFactory类311

主动对象：ActiveObjectImpl类312

示例程序2的运行313

12.7 本章所学知识314

12.8 练习题315

第13章 总结——多线程编程的模式语言321

13.1 多线程编程的模式语言322

模式与模式语言322

13.2 Single Threaded Execution模式——能通过这座桥的只有一个人323

13.3 Immutable模式——想破坏也破坏不了324

13.4 Guarded Suspension模式——等我准备好哦325

13.5 Balking模式——不需要就算了326

13.6 Producer-Consumer模式——我来做，你来用327

13.7 Read-Write Lock模式——大家一起读没问题，但读的时候不要写哦328

13.8 Thread-Per-Message模式——这项工作就交给你了329

13.9 Worker Thread模式——工作没来就一直等，工作来了就干活330

13.10 Future模式——先给您提货单330

13.11 Two-Phase Termination模式——先收拾房间再睡觉331

13.12 Thread-Specific Storage模式——一个线程一个储物柜332

13.13 Active Object模式——接收异步消息的主动对象333

13.14 写在最后335

附录337

附录A 习题解答338

附录B Java内存模型447

附录C Java线程的优先级467

附录D 线程相关的主要API469

附录E java.util.concurrent包475

附录F 示例程序的运行步骤483

附录G 参考文献485