[套装书]Java高并发编程详解：深入理解并发核心库+Java高并发编程详解：多线程与架构设计+Java并发编程的艺术+Java并发编程实战（4册）

.


---------------------------Java并发编程的艺术---------------------------


并发编程领域的扛鼎之作，作者是阿里和1号店的资深Java技术专家，对并发编程有非常深入的研究，本书是他们多年一线开发经验的结晶。本书的部分内容在出版早期发表在Java并发编程网和帅foQ等技术社区，得到了非常高的评价。它选取了Java并发编程中最核心的技术进行讲解，从JDK源码、JVM、CPU等多角度全面剖析和讲解了Java并发编程的框架、工具、原理和方法，对Java并发编程进行了最为深入和透彻的阐述。

内容涵盖Java并发编程机制的底层实现原理、Java内存模型、Java并发编程基础、Java中的锁、并发容器和框架、原子类、并发工具类、线程池、Executor框架等主题，每个主题都做了深入的讲解，同时通过实例介绍了如何应用这些技术。


---------------------------Java并发编程实战---------------------------


《Java并发编程实战》深入浅出地介绍了Java线程和并发，是一本完美的Java并发参考手册。书中从并发性和线程安全性的基本概念出发，介绍了如何使用类库提供的基本并发构建块，用于避免并发危险、构造线程安全的类及验证线程安全的规则，如何将小的线程安全类组合成更大的线程安全类，如何利用线程来提高并发应用程序的吞吐量，如何识别可并行执行的任务，如何提高单线程子系统的响应性，如何确保并发程序执行预期任务，如何提高并发代码的性能和可伸缩性等内容，最后介绍了一些高级主题，如显式锁、原子变量、非阻塞算法以及如何开发自定义的同步工具类。

《Java并发编程实战》适合Java程序开发人员阅读。

.
---------------------------Java并发编程实战---------------------------


作者：盖茨（Brian Goetz） （美国）Tim Peierls （美国）Joshua Bloch 等 译者：童云兰 等
本书作者都是Java Community Process JSR 166专家组（并发工具）的主要成员,并在其他很多JCP专家组里任职。Brian Goetz有20多年的软件咨询行业经验,并著有至少75篇关于Java开发的文章。
Tim Peierls是“现代多处理器”的典范,他在BoxPop.biz、唱片艺术和戏剧表演方面也颇有研究。
Joseph Bowbeer是一个Java ME专家,他对并发编程的兴趣始于Apollo计算机时代。David Holmes是《The Java Programming Language》一书的合著者,任职于Sun公司。
Joshua Bloch是Google公司的首席Java架构师,《Effective Java》一书的作者,并参与著作了《Java Puzzlers》。
Doug Lea是《Concurrent Programming》一书的作者,纽约州立大学 Oswego分校的计算机科学教授。

1.3.4　OutputTimeUnit 14
1.3.5　三大State的使用 14
1.3.6　@Param的妙用 19
1.3.7　JMH的测试套件（Fixture） 23
1.3.8　CompilerControl 26
1.4　编写正确的微基准测试以及高级用法 27
1.4.1　编写正确的微基准测试用例 28
1.4.2　一些高级的用法 38
1.5　JMH的Profiler 45
1.5.1　StackProfiler 45
1.5.2　GcProfiler 47
1.5.3　ClassLoaderProfiler 51
1.5.4　CompilerProfiler 54
1.6　本章总结 56
第2章　Java并发包之原子类型详解 57
2.1　AtomicInteger详解 58
2.1.1　性能测试对比 58
2.1.2　AtomicInteger的基本用法 61
2.1.3　AtomicInteger内幕 66
2.1.4　AtomicInteger总结 68
2.2　AtomicBoolean详解 69
2.2.1　AtomicBoolean的基本用法 69
2.2.2　AtomicBoolean内幕 71
2.2.3　Try Lock显式锁的实现 71
2.2.4　AtomicBoolean总结 74
2.3　AtomicLong详解 74
2.4　AtomicReference详解 76
2.4.1　AtomicReference的应用场景 77
2.4.2　AtomicReference的基本用法 83
2.4.3　AtomicReference的内幕 84
2.4.4　AtomicReference总结 86
2.5　AtomicStampedReference详解 86
2.5.1　CAS算法ABA问题 86
2.5.2　AtomicStampedReference详解 87
2.5.3　AtomicStampedReference总结 89
2.6　AtomicArray详解 89
2.7　AtomicFieldUpdater详解 90
2.7.1　原子性更新对象属性 90
2.7.2　注意事项 91
2.7.3　AtomicFieldUpdater总结 93
2.8　sun.misc.Unsafe详解 93
2.8.1　如何获取Unsafe 94
2.8.2　JNI、Java和C/C++混合编程 95
2.8.3　危险的Unsafe 98
2.8.4　sun.misc.Unsafe总结 100
2.9　本章总结 100
第3章　Java并发包之工具类详解 102
3.1　CountDownLatch工具详解 102
3.1.1　等待所有子任务结束 103
3.1.2　CountDownLatch的其他方法及总结 106
3.2　CyclicBarrier工具详解 107
3.2.1　等待所有子任务结束 107
3.2.2　CyclicBarrier的循环特性 110
3.2.3　CyclicBarrier的其他方法以及总结 114
3.2.4　CyclicBarrier VS. CountDownLatch 116
3.3　Exchanger工具详解 116
3.3.1　一对线程间的数据交换 116
3.3.2　Exchanger的方法详解 121
3.3.3　Exchanger总结 123
3.4　Semaphore工具详解 124
3.4.1　Semaphore限制同时在线的用户数量 124
3.4.2　使用Semaphore定义try lock 127
3.4.3　Semaphore其他方法详解 129
3.4.4　扩展Semaphore增强release 135
3.4.5　Semaphore总结 138
3.5　Phaser工具详解 138
3.5.1　Phaser的基本用法 138
3.5.2　Phase（阶段）以及Phaser方法详解 144
3.5.3　Phaser层级关系 148
3.5.4　Phaser总结 149
3.6　Lock&ReentrantLock详解 150
3.6.1　Lock及ReentrantLock方法详解 150
3.6.2　正确使用显式锁Lock 152
3.6.3　ReentrantLock VS. Synchronized关键字 158
3.6.4　显式锁Lock总结 164
3.7　ReadWriteLock&ReentrantRead-WriteLock详解 165
3.7.1　读写锁的基本使用方法 165
3.7.2　读写锁的方法 167
3.7.3　基准测试性能对比 167
3.7.4　读写锁总结 170
3.8　Condition详解 171
3.8.1　初识Condition 171
3.8.2　Condition接口方法详解 174
3.8.3　使用Condition之生产者消费者 177
3.8.4　Condition总结 181
3.9　StampedLock详解 181
3.9.1　读写锁的饥饿写问题 182
3.9.2　StampedLock的使用 183
3.9.3　与其他锁的性能对比 185
3.9.4　StampedLock总结 191
3.10　Guava之Monitor详解 192
3.10.1　Monitor及Guard 192
3.10.2　Monitor的其他方法 194
3.10.3　Monitor总结 194
3.11　Guava之RateLimiter详解 194
3.11.1　RateLimiter的基本使用 195
3.11.2　RateLimiter的限流操作——漏桶算法 196
3.11.3　令牌环桶算法 201
3.11.4　RateLimiter总结 204
3.12　本章总结 204
第4章　Java并发包之并发容器详解 205
4.1　链表 206
4.1.1　基本的链表 206
4.1.2　优先级链表 210
4.1.3　跳表（SkipList） 213
4.1.4　链表总结 221
4.2　BlockingQueue（阻塞队列） 221
4.2.1　ArrayBlockingQueue 222
4.2.2　PriorityBlockingQueue 226
4.2.3　LinkedBlockingQueue 228
4.2.4　DelayQueue 228
4.2.5　SynchronousQueue 231
4.2.6　LinkedBlockingDeque 233
4.2.7　LinkedTransferQueue 234
4.2.8　BlockingQueue总结 236
4.3　ConcurrentQueue（并发队列） 237
4.3.1　并发队列的性能 239
4.3.2　并发队列在使用中需要注意的问题 241
4.3.3　并发队列总结 245
4.4　ConcurrentMap（并发映射） 245
4.4.1　ConcurrentHashMap简介 245
4.4.2　ConcurrentSkipListMap简介 247
4.4.3　并发映射总结 247
4.5　写时拷贝算法（Copy On Write） 248
4.5.1　CopyOnWrite读实现操作分析 249
4.5.2　CopyOnWrite写实现操作分析 249
4.5.3　CopyOnWrite总结 250
4.6　高并发无锁（Lock Free）数据结构的实现 250
4.6.1　高并发无锁链表的实现 250
4.6.2　Lock Free数据结构的测试 253
4.6.3　本节总结 255
4.7　本章总结 255
第5章　Java并发包之ExecutorService详解 256
5.1　Executor&ExecutorService详解 256
5.1.1　ThreadPoolExecutor详解 257
5.1.2　ScheduledExecutorService详解 265
5.1.3　关闭ExecutorService 271
5.1.4　Executors详解 273
5.1.5　ExecutorService总结 276
5.2　Future和Callback 277
5.2.1　Future详解 277
5.2.2　ExecutorService与Future 280
5.2.3　Future的不足之处 282
5.2.4　Google Guava的Future 282
5.2.5　Future总结 284
5.3　ForkJoinPool 详解 284
5.3.1　Fork/Join Framework介绍 284
5.3.2　ForkJoinTask详解 285
5.3.3　ForkJoinPool总结 289
5.4　CompletionService详解 289
5.4.1　ExecutorService执行批量任务的缺陷 289
5.4.2　CompletionService详解 291
5.4.3　CompletionService总结 294
5.5　CompletableFuture详解 294
5.5.1　CompletableFuture的基本用法 294
5.5.2　任务的异步运行 296
5.5.3　异步任务链 296
5.5.4　合并多个Future 298
5.5.5　多Future的并行计算 299
5.5.6　错误处理 299
5.5.7　JDK 9对CompletableFuture的进一步支持 300
5.5.8　CompletableFuture总结 300
5.6　本章总结 301
第6章　Java Streams详解 302
6.1　Stream介绍及其基本操作 302
6.1.1　如何创建Stream 303
6.1.2　Stream之Intermediate操作 306
6.1.3　Stream之Terminal操作 312
6.1.4　NumericStream详解 317
6.1.5　Stream总结 320
6.2　Collector在Stream中的使用 320
6.2.1　初识Collector 321
6.2.2　Collectors用法详解 324
6.2.3　自定义Collector 335
6.2.4　Collector总结 336
6.3　Parallel Stream详解 337
6.3.1　并行流Parallel Stream 337
6.3.2　Spliterator 详解 340
6.3.3　Spliterator总结 343
6.4　本章总结 344
第7章　Metrics（Powerful Toolkit For Measure） 345
7.1　Metrics快速入门 345
7.1.1　如何监控度量应用程序 345
7.1.2　Metrics环境搭建 346
7.2　五大Metric详解 346
7.2.1　Meter 347
7.2.2　Gauge 349
7.2.3　Counter 360
7.2.4　Histogram 362
7.2.5　Timer 370
7.3　Reporter详解 372
7.3.1　ConsoleReporter 373
7.3.2　LogReporter 376
7.3.3　JMXReporter 378
7.3.4　CsvReporter 379
7.4　Metrics Plugins 380
7.4.1　Health Check 381
7.4.2　JVM Instrumentation 386
7.5　深入Metrics源码 387
7.5.1　MetricRegistry如何工作 388
7.5.2　Reporter如何工作 392
7.5.3　拾遗补漏 394
7.6　本章总结 396



---------------------------Java高并发编程详解：多线程与架构设计---------------------------


推荐序一
推荐序二
推荐序三
推荐序四
前言
第一部分　多线程基础
第1章　快速认识线程 3
1.1　线程的介绍 3
1.2　快速创建并启动一个线程 3
1.2.1　尝试并行运行 4
1.2.2　并发运行交替输出 5
1.2.3　使用Jconsole观察线程 6
1.3　线程的生命周期详解 7
1.3.1　线程的NEW状态 8
1.3.2　线程的RUNNABLE状态 8
1.3.3　线程的 RUNNING状态 8
1.3.4　线程的BLOCKED状态 8
1.3.5　线程的TERMINATED状态 9
1.4　线程的start方法剖析：模板设计模式在Thread中的应用 9
1.4.1　Thread start方法源码分析以及注意事项 9
1.4.2　模板设计模式在Thread中的应用 11
1.4.3　Thread模拟营业大厅叫号机程序 13
1.5　Runnable接口的引入以及策略模式在Thread中的使用 16
1.5.1　Runnable的职责 16
1.5.2　策略模式在Thread中的应用 16
1.5.3　模拟营业大厅叫号机程序 18
1.6　本章总结 19
第2章　深入理解Thread构造函数 20
2.1　线程的命名 20
2.1.1　线程的默认命名 21
2.1.2　命名线程 21
2.1.3　修改线程的名字 22
2.2　线程的父子关系 22
2.3　Thread与ThreadGroup 23
2.4　Thread与Runnable 24
2.5　Thread与JVM虚拟机栈 25
2.5.1　Thread与Stacksize 25
2.5.2　JVM内存结构 27
2.5.3　Thread与虚拟机栈 30
2.6　守护线程 33
2.6.1　什么是守护线程 33
2.6.2　守护线程的作用 34
2.7　本章总结 34
第3章　Thread API的详细介绍 35
3.1　线程sleep 35
3.1.1　sleep方法介绍 35
3.1.2　使用TimeUnit替代Thread.sleep 36
3.2　线程yield 37
3.2.1　yield方法介绍 37
3.2.2　yield和sleep 37
3.3　设置线程的优先级 38
3.3.1　线程优先级介绍 38
3.3.2　线程优先级源码分析 39
3.3.3　关于优先级的一些总结 40
3.4　获取线程ID 40
3.5　获取当前线程 41
3.6　设置线程上下文类加载器 41
3.7　线程interrupt 42
3.7.1　interrupt 42
3.7.2　isInterrupted 43
3.7.3　interrupted 45
3.7.4　interrupt注意事项 46
3.8　线程join 47
3.8.1　线程join方法详解 48
3.8.2　join方法结合实战 50
3.9　如何关闭一个线程 53
3.9.1　正常关闭 54
3.9.2　异常退出 56
3.9.3　进程假死 56
3.10　本章总结 58
第4章　线程安全与数据同步 59
4.1　数据同步 59
4.1.1　数据不一致问题的引入 59
4.1.2　数据不一致问题原因分析 61
4.2　初识 synchronized关键字 62
4.2.1　什么是synchronized 63
4.2.2　synchronized关键字的用法 63
4.3　深入synchronized关键字 65
4.3.1　线程堆栈分析 65
4.3.2　JVM指令分析 67
4.3.3　使用synchronized需要注意的问题 70
4.4　This Monitor和Class Monitor的详细介绍 72
4.4.1　this monitor 72
4.4.2　class monitor 74
4.5　程序死锁的原因以及如何诊断 77
4.5.1　程序死锁 77
4.5.2　程序死锁举例 77
4.5.3　死锁诊断 80
4.6　本章总结 81
第5章　线程间通信 82
5.1　同步阻塞与异步非阻塞 82
5.1.1　同步阻塞消息处理 82
5.1.2　异步非阻塞消息处理 83
5.2　单线程间通信 84
5.2.1　初识wait和notify 84
5.2.2　wait和notify方法详解 87
5.2.3　关于wait和notify的注意事项 89
5.2.4　wait和sleep 90
5.3　多线程间通信 90
5.3.1　生产者消费者 90
5.3.2　线程休息室wait set 93
5.4　自定义显式锁BooleanLock 94
5.4.1　synchronized关键字的缺陷 94
5.4.2　显式锁BooleanLock 95
5.5　本章总结 104
第6章　ThreadGroup详细讲解 105
6.1　ThreadGroup与Thread 105
6.2　创建ThreadGroup 105
6.3　复制Thread数组和ThreadGroup数组 106
6.3.1　复制Thread数组 106
6.3.2　复制ThreadGroup数组 109
6.4　ThreadGroup操作 109
6.4.1　ThreadGroup的基本操作 110
6.4.2　ThreadGroup的interrupt 113
6.4.3　ThreadGroup的destroy 114
6.4.4　守护ThreadGroup 115
6.5　本章总结 116
第7章　Hook线程以及捕获线程执行异常 117
7.1　获取线程运行时异常 117
7.1.1　UncaughtExceptionHandler的介绍 117
7.1.2　UncaughtExceptionHandler实例 118
7.1.3　UncaughtExceptionHandler源码分析 119
7.2　注入钩子线程 121
7.2.1　Hook线程介绍 121
7.2.2　Hook线程实战 122
7.2.3　Hook线程应用场景以及注意事项 124
7.3　本章总结 124
第8章　线程池原理以及自定义线程池 125
8.1　线程池原理 125
8.2　线程池实现 126
8.2.1　线程池接口定义 127
8.2.2　线程池详细实现 131
8.3　线程池的应用 139
8.4　本章总结 142
第二部分　Java ClassLoader
第9章　类的加载过程 144
9.1　类的加载过程简介 144
9.2　类的主动使用和被动使用 145
9.3　类的加载过程详解 148
9.3.1　类的加载阶段 148
9.3.2　类的连接阶段 149
9.3.3　类的初始化阶段 154
9.4　本章总结 156
第10章　JVM类加载器 158
10.1　JVM内置三大类加载器 158
10.1.1　根类加载器介绍 159
10.1.2　扩展类加载器介绍 159
10.1.3　系统类加载器介绍 160
10.2　自定义类加载器 161
10.2.1　自定义类加载器，问候世界 161
10.2.2　双亲委托机制详细介绍 165
10.2.3　破坏双亲委托机制 167
10.2.4　类加载器命名空间、运行时包、类的卸载等 170
10.3　本章总结 175
第11章　线程上下文类加载器 177
11.1　为什么需要线程上下文类加载器 177
11.2　数据库驱动的初始化源码分析 178
11.3　本章总结 180
第三部分　深入理解volatile关键字
第12章　volatile关键字的介绍 182
12.1　初识volatile关键字 182
12.2　机器硬件CPU 184
12.2.1　CPU Cache模型 184
12.2.2　CPU缓存一致性问题 186
12.3　Java内存模型 187
12.4　本章总结 188
第13章　深入volatile关键字 189
13.1　并发编程的三个重要特性 189
13.1.1　原子性 189
13.1.2　可见性 190
13.1.3　有序性 190
13.2　JMM如何保证三大特性 191
13.2.1　JMM与原子性 192
13.2.2　JMM与可见性 193
13.2.3　JMM与有序性 194
13.3　volatile关键字深入解析 195
13.3.1　volatile关键字的语义 195
13.3.2　volatile的原理和实现机制 197
13.3.3　volatile的使用场景 198
13.3.4　volatile和synchronized 199
13.4　本章总结 200
第14章　7种单例设计模式的设计 201
14.1　饿汉式 201
14.2　懒汉式 202
14.3　懒汉式+同步方法 203
14.4　Double-Check 204
14.5　Volatile+Double-Check 206
14.6　Holder方式 206
14.7　枚举方式 207
14.8　本章总结 208
第四部分　多线程设计架构模式
第15章　监控任务的生命周期 212
15.1　场景描述 212
15.2　当观察者模式遇到Thread 212
15.2.1　接口定义 212
15.2.2　ObservableThread实现 215
15.3　本章总结 217
15.3.1　测试运行 217
15.3.2　关键点总结 219
第16章　Single Thread Execution设计模式 220
16.1　机场过安检 220
16.1.1　非线程安全 221
16.1.2　问题分析 223
16.1.3　线程安全 225
16.2　吃面问题 225
16.2.1　吃面引起的死锁 226
16.2.2　解决吃面引起的死锁问题 228
16.2.3　哲学家吃面 229
16.3　本章总结 230
第17章　读写锁分离设计模式 231
17.1　场景描述 231
17.2　读写分离程序设计 232
17.2.1　接口定义 232
17.2.2　程序实现 234
17.3　读写锁的使用 239
17.4　本章总结 242
第18章　不可变对象设计模式 244
18.1　线程安全性 244
18.2　不可变对象的设计 244
18.2.1　非线程安全的累加器 245
18.2.2　方法同步增加线程安全性 247
18.2.3　不可变的累加器对象设计 248
18.3　本章总结 249
第19章　Future设计模式 251
19.1　先给你一张凭据 251
19.2　Future设计模式实现 251
19.2.1　接口定义 252
19.2.2　程序实现 253
19.3　Future的使用以及技巧总结 256
19.4　增强FutureService使其支持回调 257
19.5　本章总结 258
第20章　Guarded Suspension设计模式 259
20.1　什么是Guarded Suspension设计模式 259
20.2　Guarded Suspension的示例 259
20.3　本章总结 261
第21章　线程上下文设计模式 262
21.1　什么是上下文 262
21.2　线程上下文设计 263
21.3　ThreadLocal详解 264
21.3.1　ThreadLocal的使用场景及注意事项 265
21.3.2　ThreadLocal的方法详解及源码分析 265
21.3.3　ThreadLocal的内存泄漏问题分析 270
21.4　使用ThreadLocal设计线程上下文 274
21.5　本章总结 276
第22章　Balking设计模式 277
22.1　什么是Balking设计 277
22.2　Balking模式之文档编辑 278
22.2.1　Document 278
22.2.2　AutoSaveThread 280
22.2.3　DocumentEditThread 281
22.3　本章总结 283
第23章　Latch设计模式 284
23.1　什么是Latch 284
23.2　CountDownLatch程序实现 285
23.2.1　无限等待的Latch 285
23.2.2　有超时设置的Latch 289
23.3　本章总结 291
第24章　Thread-Per-Message设计模式 293
24.1　什么是Thread-Per-Message模式 293
24.2　每个任务一个线程 293
24.3　多用户的网络聊天 296
24.3.1　服务端程序 296
24.3.2　响应客户端连接的Handler 297
24.3.3　聊天程序测试 299
24.4　本章总结 300
第25章　Two Phase Termination设计模式 301
25.1　什么是Two Phase Termination模式 301
25.2　Two Phase Termination的示例 302
25.2.1　线程停止的Two Phase Termination 302
25.2.2　进程关闭的Two Phase Termination 303
25.3　知识扩展 304
25.3.1　Strong Reference及LRUCache 304
25.3.2　Soft Reference及SoftLRUCache 308
25.3.3　Weak Reference 311
25.3.4　Phantom Reference 312
25.4　本章总结 314
第26章　Worker-Thread设计模式 315
26.1　什么是Worker-Thread模式 315
26.2　Worker-Thread模式实现 315
26.2.1　产品及组装说明书 316
26.2.2　流水线传送带 317
26.2.3　流水线工人 319
26.3　本章总结 320
26.3.1　产品流水线测试 320
26.3.2　Worker-Thread和Producer-Consumer 321
第27章　Active Objects设计模式 323
27.1　接受异步消息的主动对象 323
27.2　标准Active Objects模式设计 323
27.2.1　OrderService接口设计 325
27.2.2　OrderServiceImpl 详解 325
27.2.3　OrderServiceProxy详解 326
27.2.4　MethodMessage 328
27.2.5　ActiveMessageQueue 330
27.2.6　OrderServiceFactory及测试 332
27.3　通用Active Objects框架设计 333
27.3.1　ActiveMessage详解 334
27.3.2　@ActiveMethod 336
27.3.3　ActiveServiceFactory详解 337
27.3.4　ActiveMessageQueue及其他 339
27.4　本章总结 341
第28章　Event Bus设计模式 342
28.1　Event Bus设计 343
28.1.1　Bus接口详解 343
28.1.2　同步EventBus详解 345
28.1.3　异步EventBus详解 347
28.1.4　Subscriber注册表Registry详解 348
28.1.5　Event广播Dispatcher详解 350
28.1.6　其他类接口设计 353
28.1.7　Event Bus测试 355
28.2　Event Bus实战——监控目录变化 357
28.2.1　WatchService遇到EventBus 357
28.2.2　FileChangeEvent 359
28.2.3　监控目录变化 359
28.3　本章总结 360
第29章　Event Driven设计模式 361
29.1　Event-Driven Architecture基础 361
29.1.1　Events 361
29.1.2　Event Handlers 362
29.1.3　Event Loop 363
29.2　开发一个Event-Driven框架 364
29.2.1　同步EDA框架设计 364
29.2.2　异步EDA框架设计 370
29.3　Event-Driven的使用 375
29.3.1　Chat Event 375
29.3.2　Chat Channel（Handler） 376
29.3.3　Chat User线程 377
29.4　本章总结 379


---------------------------Java并发编程的艺术---------------------------


前 言
第1章 并发编程的挑战 1
1.1 上下文切换 1
1.1.1 多线程一定快吗 1
1.1.2 测试上下文切换次数和时长 3
1.1.3 如何减少上下文切换 3
1.1.4 减少上下文切换实战 4
1.2 死锁 5
1.3 资源限制的挑战 6
1.4 本章小结 7
第2章 Java并发机制的底层实现原理 8
2.1 volatile的应用 8
2.2 synchronized的实现原理与应用 11
2.2.1 Java对象头 12
2.2.2 锁的升级与对比 13
2.3 原子操作的实现原理 16
2.4 本章小结 20
第3章 Java内存模型 21
3.1 Java内存模型的基础 21
3.1.1 并发编程模型的两个关键问题 21
3.1.2 Java内存模型的抽象结构 22
3.1.3 从源代码到指令序列的重排序 23
3.1.4 并发编程模型的分类 24
3.1.5 happens-before简介 26
3.2 重排序 27
3.2.1 数据依赖性 28
3.2.2 as-if-serial语义 28
3.2.3 程序顺序规则 29
3.2.4 重排序对多线程的影响 29
3.3 顺序一致性 31
3.3.1 数据竞争与顺序一致性 31
3.3.2 顺序一致性内存模型 32
3.3.3 同步程序的顺序一致性效果 34
3.3.4 未同步程序的执行特性 35
3.4 volatile的内存语义 38
3.4.1 volatile的特性 38
3.4.2 volatile写-读建立的happens-before关系 39
3.4.3 volatile写-读的内存语义 40
3.4.4 volatile内存语义的实现 42
3.4.5 JSR-133为什么要增强volatile的内存语义 46
3.5 锁的内存语义 47
3.5.1 锁的释放-获取建立的 happens-before关系 47
3.5.2 锁的释放和获取的内存语义 48
3.5.3 锁内存语义的实现 50
3.5.4 concurrent包的实现 54
3.6 final域的内存语义 55
3.6.1 final域的重排序规则 55
3.6.2 写final域的重排序规则 56
3.6.3 读final域的重排序规则 57
3.6.4 final域为引用类型 58
3.6.5 为什么final引用不能从构造函数内“溢出” 59
3.6.6 final语义在处理器中的实现 61
3.6.7 JSR-133为什么要增强final的语义 62
3.7 happens-before 62
3.7.1 JMM的设计 62
3.7.2 happens-before的定义 64
3.7.3 happens-before规则 65
3.8 双重检查锁定与延迟初始化 67
3.8.1 双重检查锁定的由来 67
3.8.2 问题的根源 69
3.8.3 基于volatile的解决方案 71
3.8.4 基于类初始化的解决方案 72
3.9 Java内存模型综述 78
3.9.1 处理器的内存模型 78
3.9.2 各种内存模型之间的关系 80
3.9.3 JMM的内存可见性保证 80
3.9.4 JSR-133对旧内存模型的修补 81
3.10 本章小结 82
第4章 Java并发编程基础 83
4.1 线程简介 83
4.1.1 什么是线程 83
4.1.2 为什么要使用多线程 84
4.1.3 线程优先级 85
4.1.4 线程的状态 87
4.1.5 Daemon线程 90
4.2 启动和终止线程 91
4.2.1 构造线程 91
4.2.2 启动线程 92
4.2.3 理解中断 92
4.2.4 过期的suspend()、resume()和stop() 93
4.2.5 安全地终止线程 95
4.3 线程间通信 96
4.3.1 volatile和synchronized关键字 96
4.3.2 等待/通知机制 98
4.3.3 等待/通知的经典范式 101
4.3.4 管道输入/输出流 102
4.3.5 Thread.join()的使用 103
4.3.6 ThreadLocal的使用 105
4.4 线程应用实例 106
4.4.1 等待超时模式 106
4.4.2 一个简单的数据库连接池示例 106
4.4.3 线程池技术及其示例 110
4.4.4 一个基于线程池技术的简单Web服务器 114
4.5 本章小结 118
第5章 Java中的锁 119
5.1 Lock接口 119
5.2 队列同步器 121
5.2.1 队列同步器的接口与示例 121
5.2.2 队列同步器的实现分析 124
5.3 重入锁 136
5.4 读写锁 140
5.4.1 读写锁的接口与示例 141
5.4.2 读写锁的实现分析 142
5.5 LockSupport工具 146
5.6 Condition接口 147
5.6.1 Condition接口与示例 148
5.6.2 Condition的实现分析 150
5.7 本章小结 154
第6章 Java并发容器和框架 155
6.1 ConcurrentHashMap的实现原理与使用 155
6.1.1 为什么要使用ConcurrentHashMap 155
6.1.2 ConcurrentHashMap的结构 156
6.1.3 ConcurrentHashMap的初始化 157
6.1.4 定位Segment 159
6.1.5 ConcurrentHashMap的操作 160
6.2 ConcurrentLinkedQueue 161
6.2.1 ConcurrentLinkedQueue的结构 162
6.2.2 入队列 162
6.2.3 出队列 165
6.3 Java中的阻塞队列 167
6.3.1 什么是阻塞队列 167
6.3.2 Java里的阻塞队列 168
6.3.3 阻塞队列的实现原理 172
6.4 Fork/Join框架 175
6.4.1 什么是Fork/Join框架 175
6.4.2 工作窃取算法 176
6.4.3 Fork/Join框架的设计 177
6.4.4 使用Fork/Join框架 177
6.4.5 Fork/Join框架的异常处理 179
6.4.6 Fork/Join框架的实现原理 179
6.5 本章小结 181
第7章 Java中的13个原子操作类 182
7.1 原子更新基本类型类 182
7.2 原子更新数组 184
7.3 原子更新引用类型 185
7.4 原子更新字段类 187
7.5 本章小结 188
第8章 Java中的并发工具类 189
8.1 等待多线程完成的CountDownLatch 189
8.2 同步屏障CyclicBarrier 191
8.2.1 CyclicBarrier简介 191
8.2.2 CyclicBarrier的应用场景 193
8.2.3 CyclicBarrier和CountDownLatch的区别 195
8.3 控制并发线程数的Semaphore 196
8.4 线程间交换数据的Exchanger 198
8.5 本章小结 199
第9章 Java中的线程池 200
9.1 线程池的实现原理 200
9.2 线程池的使用 203
9.2.1 线程池的创建 203
9.2.2 向线程池提交任务 205
9.2.3 关闭线程池 205
9.2.4 合理地配置线程池 206
9.2.5 线程池的监控 206
9.3 本章小结 207
第10章 Executor框架 208
10.1 Executor框架简介 208
10.1.1 Executor框架的两级调度模型 208
10.1.2 Executor框架的结构与成员 208
10.2 ThreadPoolExecutor详解 213
10.2.1 FixedThreadPool详解 213
10.2.2 SingleThreadExecutor详解 214
10.2.3 CachedThreadPool详解 215
10.3 ScheduledThreadPoolExecutor详解 217
10.3.1 ScheduledThreadPoolExecutor的运行机制 217
10.3.2 ScheduledThreadPoolExecutor的实现 218
10.4 FutureTask详解 221
10.4.1 FutureTask简介 222
10.4.2 FutureTask的使用 222
10.4.3 FutureTask的实现 224
10.5 本章小结 227
第11章 Java并发编程实践 228
11.1 生产者和消费者模式 228
11.1.1 生产者消费者模式实战 229
11.1.2 多生产者和多消费者场景 231
11.1.3 线程池与生产消费者模式 234
11.2 线上问题定位 234
11.3 性能测试 236
11.4 异步任务池 238
11.5 本章小结 240


---------------------------Java并发编程实战---------------------------


《Java并发编程实战》
对本书的赞誉
译者序
前　言
第1章　简介1
1.1　并发简史1
1.2　线程的优势2
1.2.1　发挥多处理器的强大能力2
1.2.2　建模的简单性3
1.2.3　异步事件的简化处理3
1.2.4　响应更灵敏的用户界面4
1.3　线程带来的风险4
1.3.1　安全性问题5
1.3.2　活跃性问题7
1.3.3　性能问题7
1.4　线程无处不在7
第一部分　基础知识
第2章　线程安全性11
2.1　什么是线程安全性13
2.2　原子性14
2.2.1　竞态条件15
2.2.2　示例：延迟初始化中的竞态条件16
2.2.3　复合操作17
2.3　加锁机制18
2.3.1　内置锁20
2.3.2　重入21
2.4　用锁来保护状态22
2.5　活跃性与性能23
第3章　对象的共享27
3.1　可见性27
3.1.1　失效数据28
3.1.2　非原子的64位操作29
3.1.3　加锁与可见性30
3.1.4　Volatile变量 30
3.2　发布与逸出32
3.3　线程封闭35
3.3.1　Ad-hoc线程封闭35
3.3.2　栈封闭36
3.3.3　ThreadLocal类37
3.4　不变性38
3.4.1　Final域39
3.4.2　示例：使用Volatile类型来发布不可变对象40
3.5　安全发布41
3.5.1　不正确的发布：正确的对象被破坏42
3.5.2 　不可变对象与初始化安全性42
3.5.3　安全发布的常用模式43
3.5.4　事实不可变对象44
3.5.5　可变对象44
3.5.6　安全地共享对象44
第4章　对象的组合46
4.1　设计线程安全的类46
4.1.1　收集同步需求47
4.1.2　依赖状态的操作48
4.1.3　状态的所有权48
4.2　实例封闭49
4.2.1　Java监视器模式51
4.2.2　示例：车辆追踪51
4.3　线程安全性的委托53
4.3.1　示例：基于委托的车辆追踪器54
4.3.2　独立的状态变量55
4.3.3　当委托失效时56
4.3.4　发布底层的状态变量57
4.3.5　示例：发布状态的车辆追踪器58
4.4　在现有的线程安全类中添加功能59
4.4.1　客户端加锁机制60
4.4.2　组合62
4.5　将同步策略文档化62
第5章　基础构建模块66
5.1　同步容器类66
5.1.1　同步容器类的问题66
5.1.2　迭代器与Concurrent-ModificationException68
5.1.3　隐藏迭代器69
5.2　并发容器70
5.2.1　ConcurrentHashMap71
5.2.2　额外的原子Map操作72
5.2.3　CopyOnWriteArrayList72
5.3　阻塞队列和生产者-消费者模式73
5.3.1　示例：桌面搜索75
5.3.2　串行线程封闭76
5.3.3　双端队列与工作密取77
5.4　阻塞方法与中断方法77
5.5　同步工具类78
5.5.1　闭锁79
5.5.2　FutureTask80
5.5.3　信号量82
5.5.4　栅栏83
5.6　构建高效且可伸缩的结果缓存85
第二部分　结构化并发应用程序
第6章　任务执行93
6.1　在线程中执行任务93
6.1.1　串行地执行任务94
6.1.2　显式地为任务创建线程94
6.1.3　无限制创建线程的不足95
6.2　Executor框架96
6.2.1　示例：基于Executor的Web服务器97
6.2.2　执行策略98
6.2.3　线程池98
6.2.4　Executor的生命周期99
6.2.5　延迟任务与周期任务101
6.3　找出可利用的并行性102
6.3.1　示例：串行的页面渲染器102
6.3.2　携带结果的任务Callable与Future103
6.3.3　示例：使用Future实现页面渲染器104
6.3.4　在异构任务并行化中存在的局限106
6.3.5　CompletionService:Executor与BlockingQueue106
6.3.6　示例：使用CompletionService实现页面渲染器107
6.3.7　为任务设置时限108
6.3.8　示例：旅行预定门户网站109
第7章　取消与关闭111
7.1　任务取消111
7.1.1　中断113
7.1.2　中断策略116
7.1.3　响应中断117
7.1.4　示例：计时运行118
7.1.5　通过Future来实现取消120
7.1.6　处理不可中断的阻塞121
7.1.7　采用newTaskFor来封装非标准的取消122
7.2　停止基于线程的服务124
7.2.1　示例：日志服务124
7.2.2　关闭ExecutorService127
7.2.3　“毒丸”对象128
7.2.4　示例：只执行一次的服务129
7.2.5　shutdownNow的局限性130
7.3　处理非正常的线程终止132
7.4　JVM关闭135
7.4.1　关闭钩子135
7.4.2　守护线程136
7.4.3　终结器136
第8章　线程池的使用138
8.1　在任务与执行策略之间的隐性耦合138
8.1.1　线程饥饿死锁139
8.1.2　运行时间较长的任务140
8.2　设置线程池的大小140
8.3　配置ThreadPoolExecutor141
8.3.1　线程的创建与销毁142
8.3.2　管理队列任务142
8.3.3　饱和策略144
8.3.4　线程工厂146
8.3.5　在调用构造函数后再定制ThreadPoolExecutor147
8.4　扩展 ThreadPoolExecutor148
8.5　递归算法的并行化149
第9章　图形用户界面应用程序156
9.1　为什么GUI是单线程的156
9.1.1　串行事件处理157
9.1.2　Swing中的线程封闭机制158
9.2　短时间的GUI任务160
9.3　长时间的GUI任务161
9.3.1　取消162
9.3.2　进度标识和完成标识163
9.3.3　SwingWorker165
9.4　共享数据模型165
9.4.1　线程安全的数据模型166
9.4.2　分解数据模型166
9.5　其他形式的单线程子系统167
第三部分　活跃性、性能与测试
第10章　避免活跃性危险169
10.1　死锁169
10.1.1　锁顺序死锁170
10.1.2　动态的锁顺序死锁171
10.1.3　在协作对象之间发生的死锁174
10.1.4　开放调用175
10.1.5　资源死锁177
10.2　死锁的避免与诊断178
10.2.1　支持定时的锁178
10.2.2　通过线程转储信息来分析死锁178
10.3　其他活跃性危险180
10.3.1　饥饿180
10.3.2　糟糕的响应性181
10.3.3　活锁181
第11章　性能与可伸缩性183
11.1　对性能的思考183
11.1.1　性能与可伸缩性184
11.1.2　评估各种性能权衡因素185
11.2　Amdahl定律186
11.2.1　示例：在各种框架中隐藏的串行部分188
11.2.2　Amdahl定律的应用189
11.3　线程引入的开销189
11.3.1　上下文切换190
11.3.2　内存同步190
11.3.3　阻塞192
11.4　减少锁的竞争192
11.4.1　缩小锁的范围（“快进快出”）193
11.4.2　减小锁的粒度195
11.4.3　锁分段196
11.4.4　避免热点域197
11.4.5　一些替代独占锁的方法198
11.4.6　监测CPU的利用率199
11.4.7　向对象池说“不”200
11.5　示例：比较Map的性能200
11.6　减少上下文切换的开销201
第12章　并发程序的测试204
12.1　正确性测试205
12.1.1　基本的单元测试206
12.1.2　对阻塞操作的测试207
12.1.3　安全性测试208
12.1.4　资源管理的测试212
12.1.5　使用回调213
12.1.6　产生更多的交替操作214
12.2　性能测试215
12.2.1　在PutTakeTest中增加计时功能215
12.2.2　多种算法的比较217
12.2.3　响应性衡量218
12.3　避免性能测试的陷阱220
12.3.1　垃圾回收220
12.3.2　动态编译220
12.3.3　对代码路径的不真实采样222
12.3.4　不真实的竞争程度222
12.3.5　无用代码的消除223
12.4　其他的测试方法224
12.4.1　代码审查224
12.4.2　静态分析工具224
12.4.3　面向方面的测试技术226
12.4.4　分析与监测工具226
第四部分　高级主题
第13章　显式锁227
13.1　Lock与 ReentrantLock227
13.1.1　轮询锁与定时锁228
13.1.2　可中断的锁获取操作230
13.1.3　非块结构的加锁231
13.2　性能考虑因素231
13.3　公平性232
13.4　在synchronized和ReentrantLock之间进行选择234
13.5　读-写锁235
第14章　构建自定义的同步工具238
14.1　状态依赖性的管理238
14.1.1　示例：将前提条件的失败传递给调用者240
14.1.2　示例：通过轮询与休眠来实现简单的阻塞241
14.1.3　条件队列243
14.2　使用条件队列244
14.2.1　条件谓词244
14.2.2　过早唤醒245
14.2.3　丢失的信号246
14.2.4　通知247
14.2.5　示例：阀门类248
14.2.6　子类的安全问题249
14.2.7　封装条件队列250
14.2.8　入口协议与出口协议250
14.3　显式的Condition对象251
14.4　Synchronizer剖析253
14.5　AbstractQueuedSynchronizer254
14.6　java.util.concurrent同步器类中的 AQS257
14.6.1　ReentrantLock257
14.6.2　Semaphore与CountDownLatch258
14.6.3　FutureTask259
14.6.4　ReentrantReadWriteLock259
第15章　原子变量与非阻塞同步机制261
15.1　锁的劣势261
15.2　硬件对并发的支持262
15.2.1　比较并交换263
15.2.2　非阻塞的计数器264
15.2.3　JVM对CAS的支持265
15.3　原子变量类265
15.3.1　原子变量是一种“更好的volatile”266
15.3.2　性能比较：锁与原子变量267
15.4　非阻塞算法270
15.4.1　非阻塞的栈270
15.4.2　非阻塞的链表272
15.4.3　原子的域更新器274
15.4.4　ABA问题275
第16章　Java内存模型277
16.1　什么是内存模型，为什么需要它277
16.1.1　平台的内存模型278
16.1.2　重排序278
16.1.3　Java内存模型简介280
16.1.4　借助同步281
16.2　发布283
16.2.1　不安全的发布283
16.2.2　安全的发布284
16.2.3　安全初始化模式284
16.2.4　双重检查加锁286
16.3　初始化过程中的安全性287
附录A　并发性标注289
参考文献291

.　　第三部分（第6章）主要介绍自Java 8 引入的Stream，并且重点解释了具备高并发能力的并行流原理，以及如何自定义并行流等相关内容。
　　第四部分（第7章）主要介绍Metrics这个比较小巧的度量工具集。目前Metrics已经成为事实上的度量标准，在很多开源软件、框架和平台中都能看到对它的使用，比如Apache的Kafka、Spark、Storm、Spring Cloud等都是使用Metrics作为系统运行性能指标收集的手段。
　　勘误和支持
　　由于作者的水平有限，写作时间仓促，书中难免会出现一些错误或者不准确的地方，恳请读者批评指正。如果你在阅读的过程中发现有任何问题，都欢迎将宝贵的意见发送到我的个人邮箱532500648@qq.com。我真挚地期待着你的建议和反馈，由于个人时间有限，在反馈较多的情况下，如果不能第一时间回复你的邮件还望海涵。
　　致谢
　　首先，我要感谢我的父亲，即使我早已成年，但在父亲的心里我仍是个孩子，隔三差五地提醒我注意休息，按时吃饭，我每到一个新城市，他都会关注这个城市的天气预报。作为一个七十多岁的老人，自从得知我炒股之后，他甚至开始关注股市的涨跌，生怕大盘不好时我会想不开，真是可怜天下父母心。人到中年回到家中，可以痛痛快快地喊一声“爸”，这已经是老天对我最大的善意了。
　　感谢我的妻子照顾我的生活，打理家里的琐事，在小孩的养育中承担了太多的责任，将我们两岁的双胞胎宝宝培养得如此暖心和乖巧，使得我有更多的精力和时间投入事业之中。感谢我的妻子的支持和理解，感谢你倾心倾力的付出。
　　感谢我家的双胞胎宝贝汪子敬、汪子兮兄妹，你们的加入让整个家庭变得更加温暖与温馨，为我们这个家带来欢乐。希望时间慢点走，这样我就可以更多地与你们一起嬉戏、举高高、骑大马、打地鼠、躲猫猫……无论是在路途中还是在工作休息时，你们的视频、照片、欢声与笑语填充着我所有的碎片时间。
　　感谢徐景辉（东软集团移动互联网研发部技术总监）一如既往地为我提供帮助，在我的职业生涯中，你一直作为我的导师和榜样，给我启迪，给我思路。感谢你继续为我的新书写推荐序。
　　感谢Andrew Davidson（定居在香港的澳大利亚人，OSL公司首席技术官）在写作本书的过程中为我提供宝贵的建议和相关的资料，你对我的每次求助都是有求必应，能够耐心地听我用蹩脚的英语表达我遇到的问题。感谢你再次抽出宝贵的个人时间为本书写推荐序。
　　感谢Srimanth Rudraraju（印度裔的英国人，EY安永金融服务咨询部云总监）提出的宝贵建议，当我将部分章节翻译成英文版本发送给你审阅时，你不仅耐心地读完，而且与我讨论其中的一些细节，还提出了你的看法。同样感谢你为本书写推荐序。在与你共事的那段日子里，你旺盛的精力和强大的脑容量令我印象深刻。
　　感谢Igal（来自美国加州，软件架构师，Apache软件基金会成员，开源软件Tomcat PMC成员，出版了多本图书，发表了多篇论文，拥有个人专利发明，Stack overflow的贡献者）。因在Stack overflow社区对相关问题进行讨论，得以与你相识，感谢你为我答疑解惑，同时感谢你耐心地阅读本书翻译成英文版的部分章节，并为本书写推荐序。
　　感谢我所在的公司，感谢我所在的团队，如此优秀的你们在工作中给了我很多支持和帮助，与你们共事我很荣幸，你们教会了我很多，也帮我分担了很多，感谢你们。
　　谨以此书，献给我最亲爱的家人，以及众多热爱Java开发的朋友们。
　　汪文君（Alex Wang）
　　2020年5月于兰州
　　
　　
　　---------------------------Java高并发编程详解：多线程与架构设计---------------------------
　　
　　
　　为什么写这本书
　　从大学毕业到现在已有11年的时间，在这11年中，我一直保持着一个习惯，将工作中用到的技术梳理成系统性的文档。在项目的开发过程中，由于时间的紧迫性，我们对某个技术领域知识的掌握往往都是比较碎片化的，系统化地串联知识碎片，不仅能加深对该技术的掌握，还能方便日后快速查阅，帮助记忆。截至目前，我已经在互联网上发布了大约12本电子书，主要是围绕着项目构建工具、Java开发的相关技术、NoSQL、J2EE等内容展开的。
　　2017年年初，很多人看过我写的《Java 8 之Stream》电子书之后，给我发邮件，希望我写一本能够涵盖Java 8 所有新特性的电子书。最开始一两个人这样提议的时候，我并没有在意，后来越来越多的朋友都有类似的需求，由于写电子书需要花费很长的时间，于是我尝试着将Java 8 新特性录制成视频教程，大概花了一个月的业余时间我录制了40集《汪文君Java8实战视频》，视频一经推出收获了非常多的好评，所幸大家都比较喜欢我的授课风格，在过去的2017年，我一口气录制了11套视频教程，超过400集（每集都在30分钟左右），当然也包括Java高并发相关的内容。
　　在我的计划中，关于Java高并发的内容将会发布4套视频教程，分别是：第一阶段（Java多线程基础），第二阶段（Java内存模型，高并发设计模式），第三阶段（Java并发包JUC），第四阶段（Java并发包源码剖析AQS）。其中三个阶段都已经发布了，在今日头条《心蓝说Java》中累计播放时长超过20万分钟，百度云盘下载量也超过了30万余次。由于内容太多，本书只涵盖了前两个阶段的内容，经过了数以万计读者对视频教程问题的指正，本书的写作相对比较顺利，本书内容不仅修复了视频讲解中无法修复的缺陷，而且还加入了我对Java高并发更深一层的领悟和体会。
　　本书是我第一本正式出版的书稿，关于本书的写作可以说是一次偶然的机缘巧合，在2017年9月初，机械工业出版社的策划编辑Lisa找到了我，她觉得我的视频内容比较系统，非常适合以书稿的形式发表，我们简单交流之后就快速敲定了本书内容的主体结构，围绕着高并发视频教程的前两个阶段展开，在今年我也会努力将高并发后两个阶段的内容编著成书，使之尽快与读者见面。
　　读者对象
　　计算机相关专业的在校学生。
　　从事Java语言的开发者。
　　从事Java系统架构的架构师。
　　使用Java作为开发语言的公司与集体。
　　开设Java课程的专业院校。
　　开设Java课程的培训机构。
　　如何阅读本书
　　本书主要分为四部分，其中，第一部分主要阐述Thread的基础知识，详细介绍线程的API使用、线程安全、线程间数据通信以及如何保护共享资源等内容，它是深入学习多线程内容的基础。
　　在第二部分中之所以引入ClassLoader，是因为ClassLoader与线程不无关系，我们可以通过synchronized关键字，或者Lock等显式锁的方式在代码的编写阶段对共享资源进行数据一致性保护，那么一个Class在完成初始化的整个过程到最后在方法区（JDK8 以后在元数据空间）其数据结构是怎样确保数据一致性的呢？这就需要对ClassLoader有一个比较全面的认识和了解。
　　在本书的第三部分中，我用了三章的篇幅来详细、深入地介绍volatile关键字的语义，volatile关键字在Java中非常重要，可以说它奠定了Java核心并发包的高效运行，在这一部分中，我们通过实例展示了如何使用volatile关键字并非常详细地介绍了Java内存模型等知识。
　　本书的最后一部分也就是第四部分，站在程序架构设计的角度讲解如何设计高效灵活的多线程应用程序，第四部分应该是内容最多的一部分，总共包含了15章。
　　勘误和支持
　　由于作者的水平有限，编写的时间也很仓促，书中难免会出现一些错误或者不准确的地方，恳请读者批评指正。如果在阅读的过程中发现任何问题都欢迎将您宝贵的意见发送到我的个人邮箱532500648@qq.com，我会专门在我的今日头条 《心蓝说Java》开设专栏，用于修订书中出现的错误和不妥的地方，我真挚地期待着您的建议和反馈。
　　致谢
　　首先要感谢我的父亲，在我很小的时候，他就教育我做任何事情都要脚踏实地，一步一个脚印，做人不能浮躁，任何事情都不是一蹴而就的，这也致使我在遇到发展瓶颈的时候总能够耐得住性子寻求突破。
　　在本书最后一部分编写的过程中，我的妻子经历了十月怀胎为我生下了一对龙凤胎汪子敬、汪子兮兄妹，他俩的到来让我感觉到了初为人父的激动与喜悦，更加体会到了为人父母的不容易，感谢我的妻子，多谢你的支持和理解，本书的出版应该有一半你的功劳。
　　我还要感谢在我一路成长过程中带给我很多帮助的同事及朋友——徐景辉、Andrew Davidson、Bonson、Winne、Wilson、龙含等，在本书还是草稿阶段的时候，你们就给了我很多建设性的意见和建议。
　　当然也不能忘了感谢本书的策划编辑Lisa老师，是你直接促成了本书的诞生，在过去的半年多里，你反复不断地帮我审稿，修改错别字，调整不通顺的语句，你的专业水准和敬业精神帮助我最终顺利完稿。
　　最后一定要感谢我所在的研发团队——GBDS的Jack、Eachur、Jenny、Sebastian、Yuki、Kiki、Dillon、Gavin、Wendy、Josson、Echo、Ivy、Lik、Leo、Allen、Adrian、Kevin、Ken、Terrence，以及VADM的Jeffrey、Robert、Amy、Randy等，多谢你们在工作中对我的帮助。
　　谨以此书，献给我最亲爱的家人，以及众多热爱Java开发的朋友们。
　　汪文君（Alex Wang）
　　中国，广州，2018年3月
　　
　　
　　---------------------------Java并发编程的艺术---------------------------
　　
　　
　　为什么要写这本书
　　记得第一次写并发编程的文章时还是在2012年，当时花了几个星期的时间写了一篇文章《深入分析volatile的实现原理》，准备在自己的博客中发表。在同事建法的建议下，怀着试一试的心态投向了InfoQ，庆幸的是半小时后得到InfoQ主编采纳的回复，高兴之情无以言表。这也是我第一次在专业媒体上发表文章，而后在InfoQ编辑张龙的不断鼓励和支持下，我陆续在InfoQ发表了几篇与并发编程相关的文章，于是便形成了“聊聊并发”专栏。在这个专栏的写作过程中，我得到快速的成长和非常多的帮助，在此非常感谢InfoQ的编辑们。2013年，华章的福川兄找到我，问有没有兴趣写一本书，当时觉得自己资历尚浅，婉言拒绝了。后来和福川兄一直保持联系，最后允许我花两年的时间来完成本书，所以答应了下来。由于并发编程领域的技术点非常多且深，所以陆续又邀请了同事魏鹏和朋友晓明一起参与到本书的编写当中。
　　写本书的过程也是对自己研究和掌握的技术点进行整理的过程，希望本书能帮助读者快速掌握并发编程技术。
　　本书一共11章，由三名作者共同编写完成，其中第3章和第10章节由程晓明编写，第4章和第5章由魏鹏编写，其他7章由方腾飞编写。
　　本书特色
　　本书结合JDK的源码介绍了Java并发框架、线程池的实现原理，帮助读者做到知其所以然。
　　本书对原理的剖析不仅仅局限于Java层面，而是深入到JVM，甚至CPU层面来进行讲解，帮助读者从更底层看并发技术。
　　本书结合线上应用，给出了一些并发编程实战技巧，以及线上处理并发问题的步骤和思路。
　　读者对象
　　Java开发工程师
　　架构师
　　并发编程爱好者
　　开设相关课程的大专院校师生
　　如何阅读本书
　　阅读本书之前，你必须有一定的Java基础和开发经验，最好还有一定的并发编程基础。如果你是一名并发编程初学者，建议按照顺序阅读本书，并按照书中的例子进行编码和实战。如果你有一定的并发编程经验，可以把本书当做一个手册，直接看需要学习的章节。以下是各章节的基本介绍。
　　第1章介绍Java并发编程的挑战，向读者说明进入并发编程的世界可能会遇到哪些问题，以及如何解决。
　　第2章介绍Java并发编程的底层实现原理，介绍在CPU和JVM这个层面是如何帮助Java实现并发编程的。
　　第3章介绍深入介绍了Java的内存模型。Java线程之间的通信对程序员完全透明，内存可见性问题很容易困扰Java程序员，本章试图揭开Java内存模型的神秘面纱。
　　第4章从介绍多线程技术带来的好处开始，讲述了如何启动和终止线程以及线程的状态，详细阐述了多线程之间进行通信的基本方式和等待/通知经典范式。
　　第5章介绍Java并发包中与锁相关的API和组件，以及这些API和组件的使用方式与实现细节。
　　第6章介绍了Java中的大部分并发容器，并深入剖析其实现原理，让读者领略大师的设计技巧。
　　第7章介绍了Java中的原子操作类，并给出一些实例。
　　第8章介绍了Java中提供的并发工具类，这是并发编程中的瑞士军刀。
　　第9章介绍了Java中的线程池实现原理和使用建议。
　　第10章介绍了Executor框架的整体结构和成员组件。
　　第11章介绍几个并发编程的实战，以及排查并发编程造成问题的方法。
　　勘误和支持
　　由于笔者的水平有限，编写时间仓促，书中难免会出现一些错误或者不准确的地方，恳请读者批评指正。为此，特意创建一个在线支持与应急方案的站点http://ifeve.com/book/。你可以将书中的错误发布在勘误表页面中，同时如果你遇到任何问题，也可以访问Q&A页面，我将尽量在线上为读者提供最满意的解答。书中的全部源文件除可以从华章网站下载外，还可以从并发编程网站下载，我也会将相应的功能更新及时发布出来。如果你有更多的宝贵意见，也欢迎发送邮件至邮箱tengfei@ifeve.com，期待能够得到你的真挚反馈。
　　致谢
　　感谢机械工业出版社华章公司的杨福川、高婧雅、孙海亮，在这一年多的时间中始终支持我的写作，你们的鼓励和帮助引导我顺利完成全部书稿。
　　感谢方正电子的刘老师，是他带我进入了面向对象的世界。
　　感谢我的主管朱老板，他在工作和生活上给予我很多的帮助和支持，还经常激励我完成本书编写。
　　最后感谢我的爸妈、岳父母和老婆，感谢你们的支持，并时时刻刻为我灌输信心和力量！
　　谨以此书献给我的儿子方熙皓，希望他能健康成长，以及众多热爱并发编程的朋友们，希望你们能快乐工作，认真生活！
　　方腾飞
　　
　　
　　---------------------------Java并发编程实战---------------------------
　　
　　
　　在写作本书时，对于中端桌面系统来说，多核处理器正变得越来越便宜。无独有偶，许多开发团队也注意到，在他们的项目中出现了越来越多与线程有关的错误报告。在NetBeans开发者网站上的最近一次公告中，一位核心维护人员注意到，为了修复与线程相关的问题，在某个类中竟然打了14次补丁。Dion Almaer，这位TheServerSide网站的前编辑，最近(在经过一番痛苦的调试过程并最终发现了一个与线程有关的错误之后)在其博客上写道，在大多数Java程序中充满了各种并发错误，使得程序只有在“偶然的情况下”才能正常工作。
　　确实，在开发、测试以及调试多线程程序时存在着巨大的困难，因为并发性错误通常并不会以某种确定的方式显现出来。当这些错误出现时，通常是在最糟糕的时刻，例如在正式产品中，或者在高负载的情况下。
　　当开发Java并发程序时，所要面对的挑战之一就是：平台提供的各种并发功能与开发人员在程序中需要的并发语义并不匹配。在Java语言中提供了一些底层机制，例如同步和条件等待，但在使用这些机制来实现应用级的协议与策略时必须始终保持一致。如果没有这些策略，那么在编写程序时，虽然程序看似能顺利地编译和运行，但却总会出现各种奇怪的问题。许多介绍并发的其他书籍更侧重于介绍一些底层机制和API，而在设计级的策略和模式上叙述的不多。
　　Java 5.0在Java并发应用程序的开发方面进展巨大，它不仅提供了一些新的高层组件，还补充了一些底层机制，从而使得无论是新手级开发人员还是专家级开发人员都能够更容易地构建并发应用程序。本书的作者都是JCP专家组的主要成员，也正是该专家组编写了这些新功能。本书不仅描述了这些新功能的行为和特性，还介绍了它们的底层设计模式和促使它们被添加到平台库中的应用场景。
　　我们的目标是向读者介绍一些设计规则和思维模式，从而使读者能够更容易也更乐意去构建正确的以及高性能的Java并发类和应用程序。
　　我们希望你能享受本书的阅读过程。
　　Brian Goetz
　　Williston，VT
　　2006年3月
　　

.　　我与汪文君共事过几年，我们负责的是全球性交易系统，对系统性能的要求极高。他是团队里的技术骨干，在我们共事的日子里，汪文君解决了很多技术难题，更难能可贵的是，汪文君在设计阶段就敏捷地洞察到系统可能会出现的瓶颈并且提供解决方案，而且每一个点子，每一个难题的解决之道，他都极富激情地分享给团队的所有成员。得知他要写本Java多线程的书，有幸试读了其中一些章节，感觉特别棒，他能将每一个Java多线程相关的话题都讲解得很有深度。在整本书的构想方面，各个章节的内聚性都很强，章节与章节之间又是层层推进的关系，再加以精准的图示辅助理解，让读者阅读起来感觉非常舒服。本书中所讲解的都是一个个的实战运用，对提升Java内功必然大有裨益。
　　——Development manager at HSBC Global Banking and Markets Bonson zheng
　　
　　
　　
　　---------------------------Java并发编程实战---------------------------
　　
　　
　　“我曾有幸在一个伟大的团队中工作，参与设计和实现在Java 5.0和Java 6等平台中新增的并发功能。现在，仍然是这个团队，将透彻地讲解这些新功能，以及关于并发的一般性概念。并发已不再只是高级用户谈论的话题，每一位Java开发人员都应该阅读这本书。”
　　—Martin Buchholz，Sun公司的JDK并发大师
　　“在过去30多年时间里，计算机性能一直遵循着摩尔定律，但从现在开始，它将遵循Amdahl定律。编写能高效利用多处理器的代码非常具有挑战性。 在这本书中介绍的一些概念和技术，对于在当前（以及未来的）系统上编写安全的和可伸缩的代码来说都是非常有用的。”
　　—Doron Rajwan，Intel公司研究人员
　　“如果你正在编写、设计、调试、维护以及分析多线程的Java程序，那么本书正是你所需要的。如果你曾对某个方法进行过同步，但却不理解其中的原因，那么你以及你的用户都有必要从头至尾仔细地读一读这本书。”
　　—Ted Neward，《Effective Enterprise Java》的作者
　　“Brian非常清晰地阐述了并发的一些基本问题与复杂性。对于使用线程并关注程序执行性能的开发人员来说，这是一本必读的书。”
　　—Kirk Pepperdine，JavaPerformanceTuning.com网站CTO
　　“本书深入浅出地介绍了一些复杂的编程主题，是一本完美的Java并发参考手册。书中的每一页都包含了程序员日常需要应对的问题（以及相应的解决方案）。随着摩尔定律的发展趋势由提高处理器核的速度转向增加处理器核的数量，如何有效地利用并发性已变得越来越重要，本书正好介绍了这些方面的内容。”
　　—Cliff Click博士，Azul Systems公司高级软件工程师
　　“我对并发有着浓厚的兴趣，并且与大多数程序员相比，我或许写过更多存在线程死锁的代码，也在同步上犯了更多的错误。在介绍Java线程和并发等主题的众多书籍中，Brian的这本书最具可读性，它通过循序渐进的方式将一些复杂的主题阐述得很清楚。我将本书推荐给Java Specialists?Newsletter的所有读者，因为它不仅有趣，而且很有用，它介绍了当前Java开发人员正在面对的许多问题。”
　　—Heinz Kabutz博士，Java Specialists?Newsletter的维护者
　　“我一直努力想使一些简单的问题变得更简单，然而本书已经简化了一个复杂但却关键的主题：并发。这本书采用了创新的讲解方法、简单明了的风格，它注定会成为一本非常重要的书。
　　—Bruce Tate，《Beyond Java》的作者
　　这本书为Java开发人员在线程编程领域提供了不可多得的知识。我在读这本书时受到了极大的启发，部分原因在于它详细地介绍了Java中并发领域的API，但更重要的却在于这本书以一种透彻并且易懂的方式来介绍复杂的并发知识，这是其他书籍很难媲美的。
　　—Bill Venners，《Inside the Java Virtual Machine》的作者