深入理解高并发编程：核心原理与案例实战

第1篇 基础知识
第1章 操作系统线程调度 2
1.1 冯·诺依曼体系结构 2
1.1.1 概述 2
1.1.2 计算机五大组成部分 3
1.2 CPU架构 5
1.2.1 CPU的组成部分 5
1.2.2 CPU逻辑结构 6
1.2.3 单核CPU的不足 8
1.2.4 多核CPU架构 8
1.2.5 多CPU架构 10
1.3 操作系统线程 11
1.3.1 用户级线程 11
1.3.2 内核级线程 12
1.3.3 混合级线程 14
1.4 Java线程与操作系统线程的关系 15
1.5 本章总结 16
第2章 并发编程概述 17
2.1 并发编程的基本概念 17
2.1.1 程序 17
2.1.2 进程与线程 17
2.1.3 线程组 18
2.1.4 用户线程与守护线程 19
2.1.5 并行与并发 20
2.1.6 同步与异步 21
2.1.7 共享与独享 21
2.1.8 临界区 22
2.1.9 阻塞和非阻塞 22
2.2 并发编程的风险 22
2.2.1 安全性问题 22
2.2.2 活跃性问题 23
2.2.3 性能问题 24
2.3 并发编程中的锁 24
2.3.1 悲观锁与乐观锁 24
2.3.2 公平锁与非公平锁 25
2.3.3 独占锁与共享锁 26
2.3.4 可重入锁与不可重入锁 26
2.3.5 可中断锁与不可中断锁 26
2.3.6 读/写锁 27
2.3.7 自旋锁 27
2.3.8 死锁、饥饿与活锁 27
2.4 本章总结 28
第2篇 核心原理
第3章 并发编程的三大核心问题 30
3.1 分工问题 30
3.1.1 类比现实案例 30
3.1.2 并发编程中的分工 32
3.2 同步问题 32
3.2.1 类比现实案例 33
3.2.2 并发编程中的同步 33
3.3 互斥问题 35
3.3.1 类比现实案例 35
3.3.2 并发编程中的互斥 35
3.4 本章总结 36
第4章 并发编程的本质问题 37
4.1 计算机的核心矛盾 37
4.1.1 核心矛盾概述 37
4.1.2 CPU如何解决核心矛盾 38
4.1.3 操作系统如何解决核心矛盾 38
4.1.4 编译程序如何解决核心矛盾 38
4.1.5 引发的问题 39
4.2 原子性 39
4.2.1 原子性概述 39
4.2.2 原子性问题 41
4.2.3 Java中的原子性问题 42
4.2.4 原子性问题总结 46
4.3 可见性 46
4.3.1 可见性概述 46
4.3.2 可见性问题 47
4.3.3 Java中的可见性问题 49
4.3.4 可见性问题总结 51
4.4 有序性 51
4.4.1 有序性概述 51
4.4.2 有序性问题 52
4.4.3 Java中的有序性问题 53
4.4.4 有序性问题总结 56
4.5 解决方案 57
4.5.1 原子性问题解决方案 57
4.5.2 可见性与有序性问题解决方案 57
4.6 本章总结 58
第5章 原子性的核心原理 59
5.1 原子性原理 59
5.2 处理器保证原子性 60
5.2.1 CPU保证基本内存操作的原子性 60
5.2.2 总线锁保证原子性 60
5.2.3 缓存锁保证原子性 62
5.3 互斥锁保证原子性 62
5.3.1 互斥锁模型 62
5.3.2 优化后的互斥锁模型 63
5.4 CAS保证原子性 64
5.5 本章总结 64
第6章 可见性与有序性核心原理 65
6.1 CPU多级缓存架构 65
6.1.1 CPU为何使用多级缓存架构 65
6.1.2 CPU多级缓存架构原理 66
6.1.3 CPU的计算流程 67
6.2 缓存一致性 68
6.2.1 什么是缓存一致性 68
6.2.2 缓存一致性协议 69
6.2.3 MESI协议缓存状态 70
6.2.4 MESI协议的状态转换 70
6.2.5 MESI协议带来的问题 76
6.3 伪共享 76
6.3.1 伪共享的概念 76
6.3.2 伪共享产生的场景 77
6.3.3 如何解决伪共享问题 77
6.4 volatile核心原理 78
6.4.1 保证可见性核心原理 78
6.4.2 保证有序性核心原理 79
6.4.3 volatile的局限性 81
6.5 内存屏障 82
6.5.1 编译器重排序 82
6.5.2 CPU重排序 83
6.5.3 as-if-serial原则 83
6.5.4 计算机硬件实现的内存屏障 84
6.6 Java内存模型 84
6.6.1 Java内存模型的概念 85
6.6.2 Java内存模型的八大操作 85
6.6.3 Java内存模型解决可见性与有序性问题 87
6.7 Happens-Before原则 90
6.7.1 Happens-Before原则概述 90
6.7.2 程序次序原则 90
6.7.3 volatile变量原则 91
6.7.4 传递原则 91
6.7.5 锁定原则 91
6.7.6 线程启动原则 92
6.7.7 线程终结原则 93
6.7.8 线程中断原则 93
6.7.9 对象终结原则 94
6.8 本章总结 95
第7章 synchronized核心原理 96
7.1 synchronized用法 96
7.1.1 同步实例方法 97
7.1.2 同步静态方法 98
7.1.3 同步代码块 99
7.2 Java对象结构 102
7.2.1 对象结构总览 102
7.2.2 对象头 103
7.2.3 实例数据 103
7.2.4 对齐填充 103
7.3 Java对象头 104
7.3.1 Mark Word 104
7.3.2 类型指针 106
7.3.3 数组长度 106
7.4 使用JOL查看对象信息 107
7.4.1 引入JOL环境依赖 107
7.4.2 打印对象信息 107
7.4.3 打印对象锁状态 109
7.5 synchronized核心原理 115
7.5.1 synchronized底层原理 115
7.5.2 Monitor锁原理 116
7.5.3 反编译synchronized方法 118
7.5.4 反编译synchronized代码块 119
7.6 偏向锁 121
7.6.1 偏向锁核心原理 122
7.6.2 偏向锁的撤销 122
7.6.3 偏向锁案例 123
7.7 轻量级锁 124
7.7.1 轻量级锁核心原理 124
7.7.2 轻量级锁案例 126
7.8 重量级锁 127
7.8.1 重量级锁核心原理 127
7.8.2 重量级锁案例 127
7.9 锁升级的过程 129
7.10 锁消除 130
7.11 本章总结 131
第8章 AQS核心原理 132
8.1 AQS核心数据结构 132
8.1.1 AQS数据结构原理 132
8.1.2 AQS内部队列模式 133
8.2 AQS底层锁的支持 134
8.2.1 核心状态位 134
8.2.2 核心节点类 135
8.2.3 独占锁模式 137
8.2.4 共享锁模式 142
8.3 本章总结 145
第9章 Lock锁核心原理 146
9.1 显示锁原理 146
9.2 公平锁与非公平锁原理 148
9.2.1 公平锁原理 148
9.2.2 ReentrantLock中的公平锁 149
9.2.3 公平锁实战 153
9.2.4 非公平锁原理 154
9.2.5 ReentrantLock中的非公平锁 156
9.2.6 非公平锁实战 159
9.3 悲观锁与乐观锁原理 159
9.3.1 悲观锁原理 160
9.3.2 悲观锁实战 160
9.3.3 乐观锁原理 162
9.3.4 乐观锁实战 162
9.4 可中断锁与不可中断锁原理 163
9.4.1 可中断锁原理 163
9.4.2 可中断锁实战 164
9.4.3 不可中断锁原理 166
9.4.4 不可中断锁实战 166
9.5 排他锁与共享锁原理 167
9.5.1 排他锁原理 167
9.5.2 排他锁实战 167
9.5.3 共享锁原理 169
9.5.4 共享锁实战 169
9.6 可重入锁原理 170
9.6.1 可重入锁原理 170
9.6.2 可重入锁实战 172
9.7 读/写锁原理 175
9.7.1 读/写锁原理 175
9.7.2 ReadWriteLock读/写锁 176
9.7.3 ReadWriteLock锁降级 177
9.7.4 StampedLock读/写锁 178
9.7.5 StampedLock锁的升级与降级 179
9.7.6 读/写锁实战 182
9.8 LockSupport原理 185
9.8.1 LockSupport原理 185
9.8.2 LockSupport实战 185
9.9 本章总结 187
第10章 CAS核心原理 188
10.1 CAS的基本概念 188
10.2 CAS的核心类Unsafe 189
10.2.1 Unsafe类的核心方法 190
10.2.2 Unsafe类实战 192
10.3 使用CAS实现count 194
10.3.1 案例分析 194
10.3.2 程序实现 194
10.3.3 测试程序 198
10.4 ABA问题 199
10.4.1 ABA问题概述 199
10.4.2 ABA问题解决方案 200
10.4.3 Java如何解决ABA问题 200
10.5 本章总结 202
第11章 死锁的核心原理 203
11.1 死锁的基本概念 203
11.2 死锁的分析 204
11.2.1 线程不安全 204
11.2.2 串行执行 206
11.2.3 发生死锁 208
11.3 形成死锁的必要条件 210
11.4 死锁的预防 210
11.5 本章总结 216
第12章 锁优化 217
12.1 缩小锁的范围 217
12.2 减小锁的粒度 219
12.3 锁分离 220
12.4 锁分段 221
12.5 锁粗化 221
12.6 避免热点区域问题 222
12.7 独占锁的替换方案 223
12.8 其他优化方案 223
12.9 本章总结 223
第13章 线程池核心原理 224
13.1 线程池的核心状态 224
13.1.1 核心状态说明 224
13.1.2 核心状态的流转过程 225
13.2 线程池的创建方式 227
13.2.1 通过Executors类创建线程池 227
13.2.2 通过ThreadPoolExecutor类创建线程池 229
13.2.3 通过ForkJoinPool类创建线程池 232
13.2.4 通过ScheduledThreadPoolExecutor类创建线程池 234
13.3 线程池执行任务的核心流程 235
13.3.1 执行任务的流程 235
13.3.2 拒绝策略 237
13.4 线程池的关闭方式 238
13.4.1 shutdown()方法 238
13.4.2 shutdownNow()方法 238
13.5 如何确定线程数 238
13.5.1 CPU密集型程序 238
13.5.2 I/O密集型程序 239
13.6 本章总结 239
第14章 ThreadLocal核心原理 240
14.1 ThreadLocal的基本概念 240
14.2 ThreadLocal的使用案例 241
14.3 ThreadLocal的核心原理 244
14.3.1 Thread类源码 244
14.3.2 set()方法 244
14.3.3 get()方法 245
14.3.4 remove()方法 247
14.4 ThreadLocal变量的不继承性 247
14.5 InheritableThreadLocal的使用案例 249
14.6 InheritableThreadLocal的核心原理 250
14.7 本章总结 253