多线程知识体系总结

点击一级类目即可跳转对应的链接

1. 多线程基础概念 6

1.1. 进程，线程 7

1.1.1. 进程 7

1.1.2. 线程 7

1.2. 串行，并发，并行 7

1.2.1. 串行 7

1.2.2. 并发 7

1.2.3. 并行 7

1.3. 多核下线程数量选择 7

1.3.1. 计算密集型 7

1.3.2. IO密集型 7

1.4. 线程分类 7

1.4.1. 守护线程 8

1.4.2. 用户线程 8

2. 线程的实例化方式 8

2.1. Java线程有四种实例化方法 8

2.2. 继承Thread类 8

2.3. 实现Runnable接口 8

2.4. 实现Callable接口 8

3. 线程的常用方法 9

3.1. Object的相关方法 9

3.1.1. wait()：线程进入等待状态 9

3.1.2. Notify(),notifyAll()：唤醒同步锁上处于等待状态的线程 9

3.2. Thead的静态方法 9

3.2.1. sleep()：使当前线程休眠，但不释放锁 9

3.2.2. yield()：释放CPU执行权 9

3.2.3. currentThread():获得当前线程 9

3.3. Thead的非静态方法 9

T.interrupt():设置当前线程为可中断线程。可中断t.lockInterruptibly()方式加锁并且处于等待获取锁状态的线程。但对于运行中的线程不可中断。 10

3.3.8.1. T.interrupt()和T.isInterrupted()协作来中断线程 10

3.3.8.2. sleep,wait,join中的线程被设置为可中断线程时抛出异常 10

4. 线程的生命周期 11

4.1. New 初始化 11

4.2. Runnable 可运行 11

4.3. Running 运行中 11

4.4. Block 阻塞 11

4.4.1. 等待阻塞 11

4.4.2. 同步阻塞 11

4.4.3. 其他阻塞：sleep() , join() , 发出了I/O请求 11

4.5. Dead 消亡 11

4.6. 模型图1 11

4.7. 模型图2 12

4.8. 线程的控制 13

5. 并发编程的机制研究 13

5.1. 生活实例模型 13

5.2. 并发编程的通信机制 13

5.2.1. 读-写共享变量：while条件中的共享变量用于线程之间的通讯 14

5.2.2. 等待通知机制：通过wait() notify()机制唤醒对应的线程 14

5.3. 出现线程安全的原因： 14

5.3.1. 主内存和工作内存数据不一致:JMM模型导致的 14

5.3.2. 指令的重排序：编译器或处理器导致的 14

5.4. 线程安全的处理方案：CAS，volative,synchronized,lock 14

6. java内存模型（JMM）：共享内存的并发模型 14

6.1. 模型结构：内存可见性 14

6.2. 问题 14

6.3. 处理方案 14

7. 编译器/处理器的重排序 14

7.1. 流程 14

7.2. 原则： 15

7.3. as-if-serial规则 15

7.4. happens-before规则 15

7.5. 重排序的规则 15

7.6. 内存屏障（Memory Barrier ） 15

8. DCL double-check locks(指令重排序导致的非线程安全问题) 16

8.1. 单例模式1: 非线程安全模式 16

8.2. 单例模式2：synchronized修改方法块 16

8.3. 单例模式3：DCL模式：检查-加锁-检查 16

8.4. 最终版：单例模式4：volatile变量禁止指令重排序，让DCL生效 16

8.5. 常用的单例模式：类初始化时完成实例化 17

9. Volatile-CAS-synchronized-lock对比 17

10. Synchronized：悲观锁，可重入锁 18

10.1. 特点：可重入的锁 18

10.2. 使用注意事项：区分锁对象（锁不同没有互斥作用） 18

10.3. 原理： 18

10.4. synchronized的happens-before关系：先加锁后释放锁 18

10.5. JMM中的内存可见性 18

10.6. Synchronized优化 19

11. volatile：synchronized的轻量级实现 19

11.1. 作用：保证数据的可见性，以及确保变量不会被重排序 19

11.2. 使用案例 19

11.2.1. 和Synchronized结合,用于对变量n读多写少的情况 19

11.2.2. 和CAS结合保证操作的原子性，如AtomicInteger 19

11.2.3. 修饰线程之间的共享变量 19

11.3. 注意事项：本身不具备线程安全的特性 20

12. CAS 20

12.1. 什么是CAS？ 20

12.2. 逻辑说明 20

12.3. 多线程环境下的问题 20

12.4. 处理方案：加锁，volatile变量修饰 20

12.5. CAS的应用步骤 20

12.5.1. 获取Unsafe的实例 20

12.5.2. 初始化变量的偏移量 20

12.5.3. 变量由volatile关键字修饰 20

13. AtomicInteger中CAS-volatile的应用 21

13.1. 简介 21

13.2. 属性 21

13.3. 核心方法compareAndSet(int expect, int update) 21

13.4. Get/set/getAndIncrement等方法 21

14. Unsafe中CAS的应用 21

14.1. 实例化 21

14.2. compareAndSwapInt为例 21

14.3. demo 22

15. 线程等待通知机制总结 22

15.1. 概述 22

15.2. Object.wait()/notify() 23

15.2.1. 使用案例 23

15.2.2. 运行结果 23

15.2.3. 特点 23

15.2.4. 使用场景 23

15.3. LockSupport.park()/unpark() 23

15.3.1. 使用案例 24

15.3.2. 运行结果 24

15.3.3. 特点 24

15.3.4. 使用场景 24

15.4. lock.lock()/unlock()  condition.await()/asignal() 24

15.4.1. 使用案例 24

15.4.2. 运行结果 25

15.4.3. 特点 25

15.4.4. 使用场景 25

16. LockSupport源码分析 25

16.1. 属性方法总结 26

16.1.1. final long parkBlockerOffset 线程中parkBlocker属性的偏移量 26

16.1.2. 构造函数：私有，无法被实例化 26

16.1.3. unpark(t):调用unsafe的方法，唤醒线程t 26

16.1.4. park(Object blocker)：阻塞当前线程到对象blocker 26

16.1.5. getBlocker/setBlocker: 设置线程的阻塞者对象 26

16.2. 对线程中断的响应性研究 26

16.2.1. 代码实现 26

16.2.2. 执行结果 27

17. Unsafe源码分析 27

17.1. park方法 27

17.2. unpark方法 27

18. Thread源码分析 27

18.1. volatile Object parkBlocker 属性 27

18.2. parkBlocker 使用案例： 28

19. 锁的分类 28

20. AOS 29

20.1. 锁持有者管理器AbstractOwnableSynchronizer 29

20.2. 作用：在独占模式下，用于设置当前同步对象的占用线程。 29

20.3. 为什么需要将AQS持有锁的线程的标识向上抽取 29

21. AQS:基于FIFO等待队列的阻塞锁 30

21.1. 用来做什么？ 30

21.2. 如何实现的？ 30

21.3. 设计思想 30

21.4. 类关系图 30

21.5. Jdk方法 31

21.5.1. volatile int state 相关：unsafe使用CAS协议实现 31

21.5.2. transient volatile Node head; 31

21.5.3. transient volatile Node tail; 31

21.5.4. 添加释放锁方法final 31

21.5.5. isHeldExclusively() 32

21.6. AQS.Node节点详解 32

21.7. 自定义锁源码实现 33

21.8. AQS中状态的变更 33

21.9. 头节点，尾节点设置，waitStatus的更新 33

21.10. AQS.acquire源码分析 33

21.11. AQS.release源码分析 34

21.12. AQS.acquire----AQS.release流程运转 35

22. 队列同步器与锁的区别联系 36

23. Semaphore 信号量 37

23.1. 使用场景 37

23.2. 方法： 37

23.3. 源码分析 37

23.3.1. 构造器new Semaphore(2, boolean fair); 37

23.3.2. acquire() 37

23.3.3. release() 37

23.4. Demo使用案例 37

1.1. 源码： 38

1.2. 运行结果 38

24. 常用的数据结构线程安全分析 38

24.1. ArrayList非线程安全研究 39

24.2. Vector 线程安全研究 39

24.3. HashMap  非线程安全研究 39

24.4. ConcurrentHashMap  线程安全研究 40

2. 数据问题 40

3. MESI 缓存一致性协议 41

4. 总线Lock 41

25. Synchronized-Lock的区别联系 41

25.1. 实现方式 41

25.2. 释放锁 42

25.3. 中断等待状态的线程 42

26. java.util.concurrent.locks包分析 42

26.1. 类关系图 42

26.2. Lock接口分析 42

26.2.1. 优点 42

26.2.2. 发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象 42

26.2.3. 方法 42

26.3. Condition接口分析 43

26.3.1. 特点 43

26.3.2. 方法 43

26.4. ReadWriteLock接口分析 43

26.4.1. 特点 43

26.4.2. 方法 43

26.5. ReentrantReadWriteLock案例分析 43

26.6. ReentrantLock 可重入的互斥锁 44

26.6.1. 构造方法 44

26.6.2. 常用方法 44

26.6.3. 使用案例：生产消费者模型 45

27. 介绍下Executor架构 46

27.1. 任务架构： 46

27.2. 任务提交执行架构： 46

27.3. 异步任务执行结果架构： 46

28. 任务架构： 47

28.1. Callable和Runnable对比 47

28.2. Thread 47

29. 异步任务提交执行架构 47

29.1. 类关系图 47

29.2. 示例：线程池提交Runnable任务 48

29.3. 示例：线程池提交Callable任务 48

29.4. Executor  线程提交接口 49

29.5. ExecutorService  线程池接口 49

29.5.1. 提交异步任务方法： 49

29.5.2. execute() submit()的区别 49

29.6. ScheduledExecutorService 定时调度接口 50

29.7. ThreadPoolExecutor 线程池类 50

29.7.1. 构造方法1 50

29.7.2.  构造方法2 50

29.7.3. 使用注意事项 50

29.8. Executors 工厂 50

29.8.1. 单线程的线程池newSingleThreadExecutor(...) 51

29.8.2. 创建固定大小的线程池 newFixedThreadPool(...) 51

29.8.3. 可根据需要创建新线程的线程池 newCachedThreadPool(...) 51

29.8.4. 大小不限的定时调度的线程池 newScheduledThreadPool(...) 51

29.8.5. 单线程的定时调度的线程池newSingleThreadScheduledExecutor() 51

29.9. 线程池的生命周期 51

29.9.1. 启动线程池 51

29.9.2. 关闭线程池 51

29.9.2.1. shutdown()：平缓的关闭线程池。 51

29.9.2.2. shutdownNow()：立即关闭线程池。 51

29.9.3. 线程池结束TERMINATED 52

30. 异步任务执行结果架构 52

30.1. 应用场景 52

30.2. 示例：非线程池方式获取Future实例 52

30.3. 类关系图 52

30.4. Future  异步计算结果 52

30.4.1. 常用方法 53

30.4.1.1. boolean cancel(boolean t) 尝试取消正在运行的任务 53

30.4.1.2. boolean isCancelled() 判断任务是否是在完成前被取消 53

30.4.1.3. boolean isDone() 判断任务是否已完成(含异常/取消而完成) 53

30.4.1.4. V get() 获取异步执行结果 53

30.4.1.5. V get(long timeout,TimeUnit unit) 等待时间内获取异步执行结果 53

30.5. RunnableFuture 53

30.6. FutureTask 可取消的异步计算 53

30.6.1. 构造方法 53

30.6.1.1. FutureTask(Callable<V> callable) 53

30.6.1.2. FutureTask(Runnable runnable, V result) 53

30.6.1.3. 由于FutureTask实现了Runnable接口，可start()方式启动线程 54

30.7. 获取Future对象 54

30.7.1. 线程池中submit() ,execute()方式启动的线程 54

30.7.2. 通过new FutureTask(Callable/Runnable)方式获取的Runnable实例，可start()方式启动 54

31. 线程局部变量 ThreadLocal 54

31.1. 原理，作用 54

31.2. 用法 54

31.2.1. initialValue(): 54

31.2.1.1. 源码分析 54

31.2.2. get(): 获取ThreadLocal中当前线程共享变量的值。 54

31.2.2.1. 源码分析 54

31.2.3. set(t): 设置ThreadLocal中当前线程共享变量的值。 55

31.2.3.1. 源码分析 55

31.2.4. remove(): 移除ThreadLocal中当前线程共享变量的值。 55

31.2.4.1. 源码分析 55

31.2.5. ThreadLocalMap 55

31.2.5.1. private Entry[] table; 55

31.2.5.2. private int size = 0; 55

31.2.5.3. static class Entry extends WeakReference<ThreadLocal> { 55

31.3. 案例 55

31.4. 弱引用 56

31.4.1. 弱引用导致的内存泄露 56

31.4.2. 使用弱引用的原因 56

31.4.3. 内存泄露的处理方法 56