在过去单核CPU时代，单任务在一个时间点只能执行单一程式，随着多核CPU的发展，并行程式开发就显得尤为重要。

《实战Java高并发程式设计》主要介绍基于Java的并行程式设计基础、思路、方法和实战。第一，立足于并发程式基础，详细介绍Java中进行并行程式设计的基本方法。第二，进一步详细介绍JDK中对并行程式的强大支持，帮助读者快速、稳健地进行并行程式开发。第三，详细讨论有关“锁”的最佳化和提高并行程式性能级别的方法和思路。第四，介绍并行的基本设计模式及Java 8对并行程式的支持和改进。第五，介绍高并发框架Akka的使用方法。最后，详细介绍并行程式的调试方法。

《实战Java高并发程式设计》内容丰富，实例典型，实用性强，适合有一定Java基础的技术开发人员阅读。

第1章　走入并行世界 1

1.1　何去何从的并行计算 1

1.1.1　忘掉那该死的并行 2

1.1.2　可怕的现实：摩尔定律的失效 4

1.1.3　柳暗花明：不断地前进 5

1.1.4　光明或是黑暗 6

1.2　你必须知道的几个概念 6

1.2.1　同步（Synchronous）和异步（Asynchronous） 7

1.2.2　并发（Concurrency）和并行（Parallelism） 8

1.2.3　临界区 9

1.2.4　阻塞（Blocking）和非阻塞（Non-Blocking） 9

1.2.5　死锁（Deadlock）、饥饿（Starvation）和活锁（Livelock） 9

1.3　并发级别 11

1.3.1　阻塞（Blocking） 11

1.3.2　无饥饿（Starvation-Free） 11

1.3.3　无障碍（Obstruction-Free） 12

1.3.4　无锁（Lock-Free） 12

1.3.5　无等待（Wait-Free） 13

1.4　有关并行的两个重要定律 13

1.4.1　Amdahl定律 13

1.4.2　Gustafson定律 16

1.4.3　Amdahl定律和Gustafson定律是否相互矛盾 16

1.5　回到Java：JMM 17

1.5.1　原子性（Atomicity） 18

1.5.2　可见性（Visibility） 20

1.5.3　有序性（Ordering） 22

1.5.4　哪些指令不能重排：Happen-Before规则 27

1.6　参考文献 27

第2章　Java并行程式基础 29

2.1　有关执行绪你必须知道的事 29

2.2　初始执行绪：执行绪的基本操作 32

2.2.1　新建执行绪 32

2.2.2　终止执行绪 34

2.2.3　执行绪中断 38

2.2.4　等待（wait）和通知（notify） 41

2.2.5　挂起（suspend）和继续执行（resume）执行绪 44

2.2.6　等待执行绪结束（join）和谦让（yield） 48

2.3　volatile与Java记忆体模型（JMM） 50

2.4　分门别类的管理：执行绪组 52

2.5　驻守后台：守护执行绪（Daemon） 54

2.6　先乾重要的事：执行绪优先权 55

2.7　执行绪安全的概念与synchronized 57

2.8　程式中的幽灵：隐蔽的错误 61

2.8.1　无提示的错误案例 61

2.8.2　并发下的ArrayList 62

2.8.3　并发下诡异的HashMap 63

2.8.4　初学者常见问题：错误的加锁 66

2.9　参考文献 68

第3章　JDK并发包 70

3.1　多执行绪的团队协作：同步控制 70

3.1.1　synchronized的功能扩展：重入锁 71

3.1.2　重入锁的好搭档：Condition条件 80

3.1.3　允许多个执行绪同时访问：信号量（Semaphore） 83

3.1.4　ReadWriteLock读写锁 85

3.1.5　倒计时器：CountDownLatch 87

3.1.6　循环栅栏：CyclicBarrier 89

3.1.7　执行绪阻塞工具类：LockSupport 92

3.2　执行绪复用：执行绪池 95

3.2.1　什幺是执行绪池 96

3.2.2　不要重複发明轮子：JDK对执行绪池的支持 97

3.2.3　刨根究底：核心执行绪池的内部实现 102

3.2.4　超负载了怎幺办：拒绝策略 106

3.2.5　自定义执行绪创建：ThreadFactory 109

3.2.6　我的套用我做主：扩展执行绪池 110

3.2.7　合理的选择：最佳化执行绪池执行绪数量 112

3.2.8　堆叠去哪里了：线上程池中寻找堆叠 113

3.2.9　分而治之：Fork/Join框架 117

3.3　不要重複发明轮子：JDK的并发容器 121

3.3.1　超好用的工具类：并发集合简介 121

3.3.2　执行绪安全的HashMap 122

3.3.3　有关List的执行绪安全 123

3.3.4　高效读写的伫列：深度剖析ConcurrentLinkedQueue 123

3.3.5　高效读取：不变模式下的CopyOnWriteArrayList 129

3.3.6　数据共享通道：BlockingQueue 130

3.3.7　随机数据结构：跳表（SkipList） 134

3.4　参考资料 136

第4章　锁的最佳化及注意事项 138

4.1　有助于提高“锁”性能的几点建议 139

4.1.1　减小锁持有时间 139

4.1.2　减小锁粒度 140

4.1.3　读写分离锁来替换独占锁 142

4.1.4　锁分离 142

4.1.5　锁粗化 144

4.2　Java虚拟机对锁最佳化所做的努力 146

4.2.1　锁偏向 146

4.2.2　轻量级锁 146

4.2.3　自旋锁 146

4.2.4　锁消除 146

4.3　人手一支笔：ThreadLocal 147

4.3.1　ThreadLocal的简单使用 148

4.3.2　ThreadLocal的实现原理 149

4.3.3　对性能有何帮助 155

4.4　无锁 157

4.4.1　与众不同的并发策略：比较交换（CAS） 158

4.4.2　无锁的执行绪安全整数：AtomicInteger 159

4.4.3　Java中的指针：Unsafe类 161

4.4.4　无锁的对象引用：AtomicReference 162

4.4.5　带有时间戳的对象引用：AtomicStampedReference 165

4.4.6　数组也能无锁：AtomicIntegerArray 168

4.4.7　让普通变数也享受原子操作：AtomicIntegerFieldUpdater 169

4.4.8　挑战无锁算法：无锁的Vector实现 171

4.4.9　让执行绪之间互相帮助：细看SynchronousQueue的实现 176

4.5　有关死锁的问题 179

4.6　参考文献 183

第5章　并行模式与算法 184

5.1　探讨单例模式 184

5.2　不变模式 187

5.3　生产者-消费者模式 190

5.4　高性能的生产者-消费者：无锁的实现 194

5.4.1　无锁的快取框架：Disruptor 195

5.4.2　用Disruptor实现生产者-消费者案例 196

5.4.3　提高消费者的回响时间：选择合适的策略 199

5.4.4　CPU Cache的最佳化：解决伪共享问题 200

5.5　Future模式 204

5.5.1　Future模式的主要角色 206

5.5.2　Future模式的简单实现 207

5.5.3　JDK中的Future模式 210

5.6　并行流水线 212

5.7　并行搜寻 216

5.8　并行排序 218

5.8.1　分离数据相关性：奇偶交换排序 218

5.8.2　改进的插入排序：希尔排序 221

5.9　并行算法：矩阵乘法 226

5.10　準备好了再通知我：网路NIO 230

5.10.1　基于Socket的服务端的多执行绪模式 230

5.10.2　使用NIO进行网路编程 235

5.10.3　使用NIO来实现客户端 243

5.11　读完了再通知我：AIO 245

5.11.1　AIO EchoServer的实现 245

5.11.2　AIO Echo客户端实现 248

5.12　参考文献 249

第6章　Java 8与并发 251

6.1　Java 8的函式式编程简介 251

6.1.1　函式作为一等公民 252

6.1.2　无副作用 252

6.1.3　申明式的（Declarative） 253

6.1.4　不变的对象 254

6.1.5　易于并行 254

6.1.6　更少的代码 254

6.2　函式式编程基础 255

6.2.1　FunctionalInterface注释 255

6.2.2　接口默认方法 256

6.2.3　lambda表达式 259

6.2.4　方法引用 260

6.3　一步一步走入函式式编程 263

6.4　并行流与并行排序 267

6.4.1　使用并行流过滤数据 267

6.4.2　从集合得到并行流 268

6.4.3　并行排序 268

6.5　增强的Future：CompletableFuture 269

6.5.1　完成了就通知我 269

6.5.2　异步执行任务 270

6.5.3　流式调用 272

6.5.4　CompletableFuture中的异常处理 272

6.5.5　组合多个CompletableFuture 273

6.6　读写锁的改进：StampedLock 274

6.6.1　StampedLock使用示例 275

6.6.2　StampedLock的小陷阱 276

6.6.3　有关StampedLock的实现思想 278

6.7　原子类的增强 281

6.7.1　更快的原子类：LongAdder 281

6.7.2　LongAdder的功能增强版：LongAccumulator 287

6.8　参考文献 288

第7章　使用Akka构建高并发程式 289

7.1　新并发模型：Actor 290

7.2　Akka之Hello World 290

7.3　有关讯息投递的一些说明 293

7.4　Actor的生命周期 295

7.5　监督策略 298

7.6　选择Actor 303

7.7　讯息收件箱（Inbox） 303

7.8　讯息路由 305

7.9　Actor的内置状态转换 308

7.10　询问模式：Actor中的Future 311

7.11　多个Actor同时修改数据：Agent 313

7.12　像资料库一样操作记忆体数据：软体事务记忆体 316

7.13　一个有趣的例子：并发粒子群的实现 319

7.13.1　什幺是粒子群算法 320

7.13.2　粒子群算法的计算过程 320

7.13.3　粒子群算法能做什幺 322

7.13.4　使用Akka实现粒子群 323

7.14　参考文献 330

第8章　并行程式调试 331

8.1　準备实验样本 331

8.2　正式起航 332

8.3　挂起整个虚拟机 334

8.4　调试进入ArrayList内部