/java-concurrent-programming

:notebook: 《实战Java 高并发程序设计》笔记和源码整理

Primary LanguageJavaMIT LicenseMIT

《实战Java高并发程序设计》笔记和源码

笔记

  • 《实战Java高并发程序设计》中有很多代码范例，适合初学者通过实践入门并发编程，这本书有个问题就是前面的代码都用JDK7，第六章开始又用JDK8了
  • 笔者做了相关笔记并整理源代码，欢迎交流和 Star
  • 由于除了jdk外，需要引入第三方包，故而使用maven来进行包管理，建议运行代码前安装好maven环境
  • 笔记在 notes，源代码在 src/main/java
  • 如有需要电子书，可去我的repo中访问awesome-books仓库下载
  • part-部，chapter-章，section-节，paragraph/fragment/segment-完整的一段，passage-篇
  • 笔记中使用的JDK源代码仓库，fork于zxiaofan的JDK仓库
  • 彻底删除git中的大文件

书籍概况

  • 作者: 葛一鸣 / 郭超
  • 出版社: 电子工业出版社
  • 出版年: 2015-11
  • 页数: 352
  • 定价: 69.00元
  • ISBN: 9787121273049

目录

  • 第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内部 336