阶段十：总结v专题（第二章：并发篇）

）)

第二章：并发篇

1. 线程状态

要求

• 掌握 Java 线程六种状态
• 掌握 Java 线程状态之间的转换
• 能理解五种状态与六种状态两种说法的区别

六种状态及转换

分别是

• 新建
  • 当一个线程对象被创建，但还未调用 start 方法时处于新建状态
  • 此时未与操作系统底层线程关联
• 可运行
  • 调用了 start 方法，就会由新建进入可运行
  • 此时与底层线程关联，由操作系统调度执行
• 终结
  • 线程内代码已经执行完毕，由可运行进入终结
  • 此时会取消与底层线程关联

上面的三种转换都是单向的

• 阻塞
  • 当获取锁失败后，由可运行进入 Monitor 的阻塞队列阻塞，此时不占用 cpu 时间
  • 当持锁线程释放锁时，会按照一定规则唤醒阻塞队列中的阻塞线程，唤醒后的线程获取锁成功后进入可运行状态
• 等待
  • 当获取锁成功后，但由于条件不满足，调用了 wait() 方法，此时从可运行状态释放锁进入 Monitor 等待集合 等待，同样不占用 cpu 时间
  • 当其它持锁线程调用 notify() 或 notifyAll() 方法，会按照一定规则唤醒等待集合中的等待线程，重新去争抢锁，争抢成功后恢复为可运行状态；（如果被唤醒了，但是未抢到锁，则是阻塞状态）
• 有时限等待
  • 当获取锁成功后，但由于条件不满足，调用了 wait(long) 方法，此时从可运行状态释放锁进入 Monitor 等待集合进行 有时限等待，同样不占用 cpu 时间
  • 当其它持锁线程调用 notify() 或 notifyAll() 方法，会按照一定规则唤醒等待集合中的 有时限等待线程，重新去争抢锁,争抢成功后恢复为可运行状态；（如果被唤醒了，但是未抢到锁，则是阻塞状态）
  • 如果等待超时，唤醒等待集合中的 有时限等待线程，并重新去竞争锁，竞争成功后会从有时限等待状态恢复为 可运行 状态；（如果被唤醒了，但是未抢到锁，则是阻塞状态）
  • 还有一种情况是调用 sleep(long) 方法也会从可运行状态进入有时限等待状态，但与 Monitor 无关，不需要主动唤醒，超时时间结束就会恢复为可运行状态；（不需要跟锁，不跟是否满足条件相关联）

其它情况（只需了解）

• 可以用 interrupt() 方法打断等待、有时限等待的线程，让它们恢复为可运行状态
• park，unpark 等方法也可以让线程等待和唤醒

五种状态

五种状态的说法来自于操作系统层面的划分

• 运行态：分到 cpu 时间，能真正执行线程内代码的
• 就绪态：有资格分到 cpu 时间，但还未轮到它的
• 阻塞态：没资格分到 cpu 时间的
  • 涵盖了 java 状态中提到的阻塞、等待、有时限等待
  • 多出了阻塞 I/O，指线程在调用阻塞 I/O 时，实际工作由 I/O 设备完成，此时线程无事可做，只能干等
• 新建与终结态：与 java 中同名状态类似，不再啰嗦

注意： Java 中的 RUNNABLE 涵盖了就绪、运行、阻塞 I/O

2. 线程池

要求

• 掌握线程池的 7 大核心参数

七大参数

1. corePoolSize 核心线程数目 - 池中会保留的最多线程数
2. maximumPoolSize 最大线程数目 - 核心线程+救急线程的最大数目
3. keepAliveTime 生存时间 - 救急线程的生存时间，生存时间内没有新任务，此线程资源会释放
4. unit 时间单位 - 救急线程的生存时间单位，如秒、毫秒等
5. workQueue 任务队列- 当没有空闲核心线程时，新来任务会加入到此队列排队，队列满会创建救急线程执行任务
6. threadFactory 线程工厂 - 可以定制线程对象的创建，例如设置线程名字、是否是守护线程等
7. handler 拒绝策略 - 当所有线程都在繁忙，workQueue （任务队列）也放满时，会触发拒绝策略
   1. 抛异常 java.util.concurrent.ThreadPoolExecutor.AbortPolicy
   2. 由调用者执行任务 java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
   3. 丢弃任务 java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
   4. 丢弃最早排队任务 java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy

注：
核心线程：完成任务后需要保留的线程；
救急线程（被上面的3、4控制）：完成任务后不需要保留的线程；
submit(tast)创建一个任务，并将任务添加到任务队列；

任务队列和核心线程都是有上限的，当都满时，有任务进来会创建救急线程来应急；

注：
  核心线程都忙着呢，此时又来了一个任务；该任务会被放入任务队列，当任务队列都被放满了，又来了一个任务A，若此时核心线程还是忙着呢，就会创建一个救急线程来执行任务A，当A被执行完成后，救急线程不急着销毁，而是去执行任务队列中的线程（遵循先进先出的原则）；
  若核心线程，任务队列，救急线程都满了。又来了一个任务，此时就会执行拒绝策略啦；

代码说明
day02.TestThreadPoolExecutor 以较为形象的方式演示了线程池的核心组成

3. wait vs sleep

要求

• 能够说出二者区别

一个共同点，三个不同点

共同点

• wait() ，wait(long) 和 sleep(long) 的效果都是让当前线程暂时放弃 CPU 的使用权，进入阻塞状态

不同点

• 方法归属不同

  • sleep(long) 是 Thread 的静态方法
  • 而 wait()，wait(long) 都是 Object 的成员方法，每个对象都有

• 醒来时机不同

  • 执行 sleep(long) 和 wait(long) 的线程都会在等待相应毫秒后醒来
  • wait(long) 和 wait() 还可以被 notify 唤醒，wait() 如果不唤醒就一直等下去
  • 它们都可以被打断唤醒

• 锁特性不同（重点）

  • wait 方法的调用必须先获取 wait 对象的锁，而 sleep 则无此限制
  • wait 方法执行后会释放对象锁，允许其它线程获得该对象锁（我放弃 cpu，但你们还可以用）
  • 而sleep如果在synchronized代码块中执行，并不会释放对象锁（我放弃 cpu，你们也用不了）

4. lock vs synchronized

lock 和 synchronized都是锁，有一些共同点和不同点
要求

• 掌握 lock 与 synchronized 的区别
• 理解ReentrantLock的公平、非公平锁
• 理解 ReentrantLock 中的条件变量

三个层面

• 语法层面

  • synchronized 是关键字，源码在 jvm 中，用 c++ 语言实现
  • Lock 是接口，源码由jdk提供，用java语言实现
  • 使用 synchronized 时，退出同步代码块锁会自动释放，而使用Lock时，需要手动调用unlock方法释放锁

• 功能层面

  • 二者均属于悲观锁、都具备基本的互斥（多个线程，只有一个能得到锁）、同步（所有线程同时运行）、锁重入功能（可以给同一个对象加多道锁）

  • Lock 提供了许多 synchronized 不具备的功能，例如（Lock能得到的信息更多）获取等待状态、公平锁、可打断、可超时、多条件变量

    公平锁就是一些失败的线程再次争抢锁是先到先得，非公平锁允许插队效率更高；
    /
    对于未抢到锁的线程synchronized不可打断、不可超时（死等），Lock不会；

  • Lock 有适合不同场景的实现，如 ReentrantLock（可重入）， ReentrantReadWriteLock（适合读多写少）

• 性能层面

  • 在没有竞争时，synchronized 做了很多优化，如偏向锁、轻量级锁，性能好
  • 在竞争激烈时，Lock 的实现通常会提供更好的性能

公平锁

• 公平锁的公平体现
  • 已经处在阻塞队列中的线程（不考虑超时）始终都是公平的，先进先出
  • 公平锁是指未处于阻塞队列中的线程来争抢锁，如果队列不为空，则老实到队尾等待
  • 非公平锁是指未处于阻塞队列中的线程来争抢锁，与队列头唤醒的线程去竞争，谁抢到算谁的
• 公平锁会降低吞吐量，一般不用

条件变量

• ReentrantLock 中的条件变量功能类似于普通 synchronized 的 wait，notify，用在当线程获得锁后，发现条件不满足时，临时等待的链表结构
• 与 synchronized 的等待集合不同之处在于，ReentrantLock 中的条件变量可以有多个，可以实现更精细的等待、唤醒控制

代码说明

• day02.TestReentrantLock 用较为形象的方式演示 ReentrantLock 的内部结构

5. volatile

要求

• 掌握线程安全要考虑的三个问题
• 掌握 volatile 能解决哪些问题

线程安全要考虑三个方面：可见性、有序性、原子性

• 可见性指，一个线程对共享变量修改，另一个线程能看到最新的结果
• 有序性指，一个线程内代码按编写顺序执行
• 原子性指，一个线程内多行代码以一个整体运行，期间不能有其它线程的代码插队

volatile 能够保证共享变量的可见性与有序性，但并不能保证原子性

• 原子性举例
• 可见性举例
• 有序性举例

原子性

• 起因：多线程下，不同线程的指令发生了交错导致的共享变量的读写混乱

  产生根源：①.代码可能并不是原子的，看起来的一行代码编译成字节码可能就是有多条指令；②.在多线程下，各线程的多条指令发生了交错，就可能出现错误的结果；

• 解决：用悲观锁或乐观锁解决，volatile 并不能解决原子性

可见性

• 起因：由于编译器优化、或缓存优化、或 CPU 指令重排序优化导致的对共享变量所做的修改另外的线程看不到

  
  ----
    读写物理内存的效率是很慢的，上图中CPU-0在0.1秒内竟然读取了一千万次，这时JIT就看不下去了，JIT主要是想对热点代码（频繁执行的方法，反复执行的循环）进行优化，JIT将字节码编译成了机器码，避免了反复读写物理内存（既然读了这么多次都是false，那就干脆直接不读了，默认就是false吧）
    禁用JIT就可以正常执行了（但却失去了运行的效率优化），也可以减少执行的次数使其运行相同方法或循环不频繁），但都不是正确的根本性解决办法；
    根本解决办法：用 volatile 修饰共享变量，

• 解决：用 volatile 修饰共享变量，能够防止编译器等优化发生，让一个线程对共享变量的修改对另一个线程可见
  

有序性

• 起因：由于编译器优化、或缓存优化、或 CPU 指令重排序优化导致指令的实际执行顺序与编写顺序不一致
• 解决：用 volatile 修饰共享变量会在读、写共享变量时加入不同的屏障，阻止其他读写操作越过屏障，从而达到阻止重排序的效果
• 注意（要想用volatile解决有序性，首先要明白它的原理，放的位置不同，结果是迥异的）：
  • volatile 变量写加的屏障是阻止上方其它写操作越过屏障排到 volatile 变量写之下
  • volatile 变量读加的屏障是阻止下方其它读操作越过屏障排到 volatile 变量读之上
  • volatile 读写加入的屏障只能防止同一线程内的指令重排

代码说明

• day02.threadsafe.AddAndSubtract 演示原子性
• day02.threadsafe.ForeverLoop 演示可见性
  • 注意：本例经实践检验是编译器优化导致的可见性问题
• day02.threadsafe.Reordering 演示有序性
  • 需要打成 jar 包后测试
• 请同时参考视频讲解

6. 悲观锁 vs 乐观锁

要求

• 掌握悲观锁和乐观锁的区别

对比悲观锁与乐观锁

• 悲观锁的代表是 synchronized 和 Lock 锁

  • 其核心思想是【线程只有占有了锁，才能去操作共享变量，每次只有一个线程占锁成功，获取锁失败的线程，都得停下来等待】
  • 线程从运行到阻塞、再从阻塞到唤醒，涉及线程上下文切换（要把线程的状态记录下来），若频繁发生，影响性能
  • 实际上，线程在获取 synchronized 和 Lock 锁时，如果锁已被占用，都会做几次重试操作，减少阻塞的机会

  

• 乐观锁的代表是 AtomicInteger，使用 cas 来保证原子性

  • 其核心思想是【无需加锁，每次只有一个线程能成功修改共享变量，其它失败的线程不需要停止，不断重试直至成功】
  • 由于线程一直运行，不需要阻塞，因此不涉及线程上下文切换
  • 它需要多核 cpu 支持，且线程数不应超过 cpu 核数

  
  乐观锁会发生指令交错

代码说明

• day02.SyncVsCas 演示了分别使用乐观锁和悲观锁解决原子赋值
• 请同时参考视频讲解

7. Hashtable vs ConcurrentHashMap

要求

• 掌握 Hashtable 与 ConcurrentHashMap 的区别
• 掌握 ConcurrentHashMap 在不同版本的实现区别

更形象的演示，见资料中的 hash-demo.jar，运行需要 jdk14 以上环境，进入 jar 包目录，执行下面命令

java -jar --add-exports java.base/jdk.internal.misc=ALL-UNNAMED hash-demo.jar

Hashtable 对比 ConcurrentHashMap

• Hashtable 与 ConcurrentHashMap 都是线程安全的 Map 集合，他们的键和值都是不能为空哒；（Hashtable扩容是乘2加1）
• Hashtable 并发度低，整个 Hashtable 对应一把锁，同一时刻，只能有一个线程操作它
• ConcurrentHashMap 并发度高，整个 ConcurrentHashMap 对应多把锁，只要线程访问的是不同锁，那么不会冲突

ConcurrentHashMap 1.7

• 数据结构：Segment(大数组) + HashEntry(小数组) + 链表，每个 Segment 对应一把锁，如果多个线程访问不同的 Segment，则不会冲突

• 并发度：Segment 数组大小即并发度，决定了同一时刻最多能有多少个线程并发访问。Segment 数组不能扩容，意味着并发度在 ConcurrentHashMap 创建时就固定了

  

• Segment索引计算

  • 假设大数组长度是 $2^m$，key 在大数组内的索引是 key 的 二次 hash 值（二进制） 的高 m 位
  • 假设小数组长度是 $2^n$，key 在小数组内的索引是 key 的 二次 hash 值（二进制） 的低 n 位

  

• 扩容：Segment(大数组）不能扩容，每个 小数组的扩容相对独立（各个小数组各扩各的），小数组在超过扩容因子（长度的3/4）时会触发扩容，每次扩容翻倍

• Segment[0] 原型：首次创建其它小数组时，会以当前的此原型为依据，数组长度，扩容因子都会以原型为准

ConcurrentHashMap 1.8

• 数据结构：Node 数组 + 链表或红黑树，数组的每个头节点作为锁（每个链表的头上是锁），如果多个线程访问的头节点不同，则不会冲突。首次生成头节点时如果发生竞争，利用 cas （乐观）而非 syncronized（悲观），进一步提升性能

• 并发度：Node 数组有多大，并发度就有多大（数组的容量决定了并发度），与 1.7 不同，Node 数组可以扩容

• 扩容条件：Node 数组 满 3/4 时就会扩容，扩容结果是数组乘2；

• 演示扩容，说明三个问题 forwardingNode ，扩容时的 get，扩容时的put

  • 扩容单位：以链表为单位从后向前迁移链表，迁移完成的将旧数组头节点替换为 ForwardingNode（数组元素是ForwardingNode说明该元素已经被迁移完成了；）

  • 扩容时并发 get（不会阻塞）

    • 根据是否为 ForwardingNode 来决定是在新数组查找还是在旧数组查找，不会阻塞
    • 如果链表长度超过 1，则需要对节点进行复制（创建新节点）；怕的是节点迁移后 next 指针改变（链表迁移时，链表对象要重新创建）
    • 如果链表最后几个元素扩容后索引不变，则节点无需复制

    

  • 扩容时并发 put

    • 如果 put 的线程与扩容线程操作的链表（扩容时会对操作到的链表头加锁）是同一个，put 线程会阻塞
    • 如果 put 的线程操作的链表还未迁移完成，即头节点不是 ForwardingNode，则可以并发执行
    • 如果 put 的线程操作的链表已经迁移完成，即头结点是 ForwardingNode，则可以协助扩容（不让它闲着）

• 初始化时机：与 1.7 相比是懒惰初始化（构造方法一调用，数组结构不创建，第一次往里面put元素时创建底层数组结构（饿汉式））

• 理解 capacity （容量）和 factor（因子）

  • capacity 代表预估的元素个数，capacity 与 factory 来计算出初始数组大小，需要贴近 $2^n$
  • Factor 只在计算初始数组大小时被使用，之后扩容固定为 3/4

• 超过树化阈值时的扩容问题，如果容量已经是 64，直接树化，否则在原来容量基础上做 3 轮扩容

ConcurrentHashMap 1.7与ConcurrentHashMap 1.8相比：

• 数据结构：
  • 1.7：Segment(大数组) + HashEntry(小数组) + 链表，每个 Segment 对应一把锁，如果多个线程访问不同的 Segment，则不会冲突；
  • 1.8：Node 数组 + 链表或红黑树，数组的每个头节点作为锁（每个链表的头上是锁），如果多个线程访问的头节点不同，则不会冲突
• 初始化时机：
  • 1.7：饿汉式（构造方法一调用，segmet大数组和0号元素已经创建）
  • 1.8：懒汉式：（与 1.7 相比是懒惰初始化（构造方法一调用，数组结构不创建，第一次往里面put元素时创建底层数组结构）
• 扩容时机： 1.7是超过3/4，1.8是满3/4；

8. ThreadLocal（线程隔离）

要求

• 掌握 ThreadLocal 的作用与原理
• 掌握 ThreadLocal 的内存释放时机

作用

• 线程间（资源隔离）：ThreadLocal 可以实现【资源对象】的线程隔离，让每个线程各用各的【资源对象】，避免争用引发的线程安全问题
• 线程内（资源共享）<：ThreadLocal 同时实现了线程内的资源共享（局部变量不具备的特点）

原理

每个线程内有一个 ThreadLocalMap 类型的成员变量，用来存储资源对象【key为ThreadLocal ，value为资源对象】
（起到线程隔离的是 ThreadLocalMap 集合，ThreadLocal的作用是关联资源对象）

• 调用 set 方法，就是以 ThreadLocal 自己作为 key，资源对象作为 value，放入当前线程的 ThreadLocalMap 集合中
• 调用 get 方法，就是以 ThreadLocal 自己作为 key，到当前线程中查找关联的资源值
• 调用 remove 方法，就是以 ThreadLocal 自己作为 key，移除当前线程关联的资源值

ThreadLocalMap 的一些特点

• key 的 hash 值统一分配
• 初始容量 16，扩容因子 2/3（超过），扩容容量翻倍
• key 索引冲突后用开放寻址法解决冲突（在冲突的位置往后找下一个空闲位置作为位置）【普通map使用拉链法解决】

弱引用 key

ThreadLocalMap 中的 key 被设计为弱引用，原因如下

• Thread 可能需要长时间运行（如线程池中的线程），如果 key 不再使用，需要在内存不足（GC）时释放其占用的内存

内存释放时机

• 被动 GC（垃圾回收） 释放 key
  • 仅是让 key 的内存释放，关联 value 的内存并不会释放【value的释放要另寻机会】
• 懒惰被动释放 value
  • get key 时，发现是 null key，则释放其 value 内存
  • set key 时，会使用启发式扫描，清除临近的 null key 的 value 内存，启发次数与元素个数，是否发现 null key 有关
• 主动 remove 释放 key，value（当变量与ThreadLocal形成强引用时，不能被动回收，只能主动清理掉，主动出击）
  • 会同时释放 key，value 的内存，也会清除临近的 null key 的 value 内存
  • 推荐使用它，因为一般使用 ThreadLocal 时都把它作为静态变量（即强引用），因此无法被动依靠 GC 回收；