Java并发编程深度解析与实战

第1章　Java线程的实践及原理揭秘

1.1　如何理解系统并发

1.2　系统如何支撑高并发

1.3　线程的前世今生

1.3.1　大白话理解进程和线程

1.3.2　线程的核心价值

1.3.3　如何理解并发和并行

1.4　在Java中如何使用多线程

1.4.1　实现Runnable接口创建线程

1.4.2　继承Thread类创建线程

1.4.3　实现Callable接口并创建带返回值的线程

1.5　多线程如何应用到实际场景

1.5.1　ServerSocket

1.5.2　SocketThread

1.6　多线程的基本原理

1.7　线程的运行状态

1.7.1　线程运行状态演示

1.7.2　线程运行状态流转图

1.8　如何正确终止线程

1.8.1　关于安全中断线程的思考

1.8.2　安全中断线程之interrupt

1.8.3　如何中断处于阻塞状态下的线程

1.8.4　interrupt()方法的实现原理

1.9　理解上下文切换带来的性能影响

1.9.1　上下文切换带来的问题

1.9.2　什么是上下文切换

1.9.3　如何减少上下文切换

1.10　揭秘守护线程

1.10.1　守护线程的应用场景

1.10.2　守护线程使用注意事项

1.11　快速定位并解决线程导致的生产问题

1.11.1　死锁导致请求无法响应

1.11.2　CPU占用率很高，响应很慢

1.12　本章小结

第2章　深度揭秘synchronized实现原理

2.1　揭秘多线程环境下的原子性问题

2.1.1　深入分析原子性问题的本质

2.1.2　关于原子性问题的解决办法

2.2　Java中的synchronized同步锁

2.2.1　synchronized的使用方法

2.2.2　了解synchronized同步锁的作用范围

2.3　关于synchronized同步锁的思考

2.4　synchronzied同步锁标记存储分析

2.4.1　揭秘Mark Word的存储结构

2.4.2　图解分析对象的实际存储

2.4.3　通过ClassLayout查看对象内存布局

2.4.4　Hotspot虚拟机中对象存储的源码

2.5　synchronized的锁类型

2.5.1　偏向锁的原理分析

2.5.2　轻量级锁的原理分析

2.5.3　重量级锁的原理分析

2.6　关于CAS机制的实现原理分析

2.6.1　CAS在AtomicInteger中的应用

2.6.2　CAS实现自旋锁

2.6.3　CAS在JVM中的实现原理分析

2.7　锁升级的实现流程

2.7.1　偏向锁的实现原理

2.7.2　轻量级锁的实现原理

2.7.3　重量级锁的实现原理

2.8　synchronized使用不当带来的死锁问题

2.8.1　死锁的案例分析

2.8.2　死锁产生的必要条件

2.8.3　如何解决死锁问题

2.9　本章小结

第3章　volatile为什么能解决可见性和有序性问题

3.1　关于线程的可见性问题分析

3.1.1　思考导致问题的原因

3.1.2　volatile关键字解决可见性问题

3.2　深度理解可见性问题的本质

3.2.1　如何*大化提升CPU利用率

3.2.2　详述CPU高速缓存

3.2.3　CPU缓存一致性问题

3.2.4　总结可见性问题的本质

3.3　volatile如何解决可见性问题

3.4　指令重排序导致的可见性问题

3.4.1　什么是指令重排序

3.4.2　as-if-serial语义

3.5　从CPU层面深度剖析指令重排序的本质

3.5.1　CPU优化—Store Buffers

3.5.2　CPU优化—Store Forwarding

3.5.3　CPU优化—Invalidate Queues

3.6　通过内存屏障解决内存系统重排序问题

3.6.1　内存屏障详解

3.6.2　通过内存屏障防止重排序

3.6.3　不同CPU的重排序规则

3.6.4　总结CPU层面的可见性问题

3.7　Java Memory Mode

3.7.1　从JVM和硬件层面理解Java Memory Mode

3.7.2　JVM提供的内存屏障指令

3.8　揭秘volatile实现原理

3.9　Happens-Before模型

3.9.1　程序顺序规则

3.9.2　传递性规则

3.9.3　volatile变量规则

3.9.4　监视器锁规则

3.9.5 start规则

3.9.6　join规则

3.10　本章小结

第4章　深入浅出分析J.U.C中的重入锁和读写锁

4.1　J.U.C中与锁相关的API

4.1.1　ReentrantLock的基本应用

4.1.2　ReentrantReadWriteLock的基本应用

4.1.3　StampedLock的基本应用

4.2　ReentrantLock的设计猜想

4.2.1　锁的互斥，必须要竞争同一个共享变量

4.2.2　没有竞争到锁的线程，需要阻塞

4.2.3　需要一个容器存储被阻塞的线程

4.3　ReentrantLock实现原理分析

4.4　AbstractQueuedSynchronizer

4.5　ReentrantLock源码分析

4.5.1　ReentrantLock.lock()方法

4.5.2　AbstractQueuedSynchronizer.acquire()方法

4.5.3 NonfairSync.tryAcquire()方法

4.5.4　ReentrantLock.nofairTryAcquire()方法

4.5.5　AbstractQueuedSynchronizer.addWaiter()方法

4.5.6　AQS.acquireQueued()方法

4.6　ReentrantLock释放锁源码分析

4.6.1　ReentrantLock.tryRelease()方法

4.6.2　unparkSuccessor()方法

4.6.3　释放锁的线程继续执行

4.7　分析ReentrantReadWriteLock类的原理

4.7.1　WriteLock锁竞争原理

4.7.2　ReadLock锁竞争原理

4.7.3　ReentrantReadWriteLock中的锁降级

4.8　StampedLock的原理分析

4.8.1　核心内部类分析

4.8.2　StampedLock原理图解

4.8.3　StampedLock锁升级

4.9　本章小结

第5章　从线程通信来窥探并发中的条件等待机制

5.1　wait/notify

5.1.1　wait()/notify()方法使用实战

5.1.2　图解生产者/消费者

5.1.3　wait()/notify()方法的原理

5.1.4　wait()/notify()方法为什么要加同步锁

5.2　通过Thread.join获取线程执行结果

5.2.1　Thread.join()方法的执行流程

5.2.2　Thread.join()方法的实现原理

5.3　J.U.C中的条件控制Condition

5.3.1　Condition的基本应用

5.3.2　基于Condition的手写阻塞队列

5.4　Condition的设计猜想

5.5 Condition的源码分析

5.5.1　Condition.await()方法

5.5.2　Condition.signal()方法

5.5.3　锁竞争成功后的执行流程

5.6　本章小结

第6章　J.U.C并发工具集实战及原理分析

6.1　CountDownLatch简单介绍

6.1.1　CountDownLatch的基本使用

6.1.2 CountDownLatch运行流程

6.1.3　如何落地到实际应用

6.1.4　CountDownLatch的其他用法

6.2　CountDownLatch底层原理

6.2.1　让线程等待的await()方法到底做了什么

6.2.2　深入分析countDown()方法源码

6.2.3　线程被唤醒后的执行逻辑

6.3　Semaphore

6.3.1　Semaphore使用案例

6.3.2　Semaphore方法及场景说明

6.4　Semaphore原理分析

6.4.1　Semaphore令牌获取过程分析

6.4.2　Semaphore令牌释放过程分析

6.5　CyclicBarrier

6.5.1　CyclicBarrier的基本使用

6.5.2　基本原理分析

6.6　CyclicBarrier实现原理及源码

6.6.1　await()方法

6.6.2　reset()方法

6.7　本章小结

第7章　深度探索并发编程不得不知的工具

7.1　初步认识ThreadLocal

7.2　ThreadLocal的应用场景分析

7.3　ThreadLocal解决SimpleDateFormat线程安全问题

7.3.1 SimpleDateFormat线程安全问题的原理

7.3.2　ThreadLocal实现线程安全性

7.4　ThreadLocal实现原理分析

7.4.1　set()方法源码分析

7.4.2　get()方法源码分析

7.4.3　ThreadLocal内存泄漏

7.5　任务拆分与聚合Fork/Join

7.5.1 Fork/Join的核心API说明

7.5.2　Fork/Join的基本使用

7.6 Fork/Join的实现原理

7.6.1 WorkQueue的原理

7.6.2 工作窃取算法

7.7　Fork/Join的核心源码分析

7.7.1 任务提交过程详解

7.7.2　唤醒或者创建工作线程

7.7.3　工作线程和工作队列的绑定

7.7.4　ForkJoinWorkerThread运行过程

7.8 使用Fork/Join解决实际问题

7.8.1　项目结构说明

7.8.2　ILoadDataProcessor

7.8.3 AbstractLoadDataProcessor

7.8.4　业务服务类

7.8.5　Item聚合任务服务

7.8.6 ComplexTradeTaskService

7.8.7 测试代码

7.9　本章小结

第8章　深度剖析阻塞队列的设计原理及实现

8.1　什么是阻塞队列

8.2　Java中提供的阻塞队列

8.3　阻塞队列中提供的方法

8.4　阻塞队列的使用

8.4.1　生产者/消费者模型代码

8.4.2　图解阻塞队列实现原理

8.5 阻塞队列应用实战

8.5.1　基于阻塞队列的责任链源码

8.5.2　阻塞队列实战场景总结

8.6　详解J.U.C中阻塞队列的使用

8.6.1　基于数组结构的阻塞队列ArrayBlockingQueue

8.6.2　基于链表的阻塞队列LinkedBlockingQueue

8.6.3　优先级阻塞队列PriorityBlockingQueue

8.6.4　延迟阻塞队列DelayQueue

8.6.5　无存储结构的阻塞队列SynchronousQueue

8.6.6　阻塞队列结合体LinkedTransferQueue

8.6.7　双向阻塞队列LinkedBlockingDeque

8.7　阻塞队列的实现原理

8.7.1　put()方法说明

8.7.2　take()方法说明

8.8　本章小结

第9章　深度解读并发安全集合的原理及源码

9.1　并发安全集合ConcurrentHashMap

9.2　正确理解ConcurrentHashMap的线程安全性

9.2.1　computeIfAbsent()方法详解

9.2.2　computeIfPresent()方法详解

9.2.3　compute()方法详解

9.2.4　merge()方法详解

9.3　ConcurrentHashMap的数据结构

9.3.1　ConcurrentHashMap数据存储相关定义

9.3.2　Node数组初始化过程分析

9.3.3　单节点到链表的转化过程分析

9.3.4　扩容还是转化为红黑树

9.4　深度分析ConcurrentHashMap中的并发扩容机制

9.4.1　多线程并发扩容原理图解

9.4.2　详解ConcurrentHashMap中的数据迁移

9.5　分段锁设计提高统计元素数量的性能

9.5.1　size计数的基本原理分析

9.5.2　addCount()方法详解

9.5.3　fullAddCount()方法分析

9.6　详解红黑树的实现原理

9.6.1　什么是红黑树

9.6.2　红黑树的平衡规则

9.6.3　红黑树的平衡场景规则说明

9.6.4　红黑树插入元素平衡图解

9.6.5 红黑树规则实战解析

9.6.6　红黑树中删除元素的平衡规则

9.7　ConcurrentHashMap中红黑树的使用

9.7.1 TreeBin的基本介绍

9.7.2 链表转化成红黑树

9.7.3　自平衡

9.7.4　ConcurrentHashMap总结

9.8　Java中其他并发安全集合

9.8.1　ConcurrentLinkedQueue

9.8.2　ConcurrentLinkedDeque

9.8.3　ConcurrentSkipListMap

9.9　深度分析数据结构：跳表

9.9.1　什么是跳表

9.9.2　跳表的特性

9.9.3　跳表的基本操作

9.10　本章小结

第10章　站在架构的角度思考线程池的设计及原理

10.1　线程池的优势

10.2　Java中提供的线程池

10.2.1　线程池的使用

10.2.2　ThreadPoolExecutor

10.3　Executor框架详解

10.4　线程池的设计猜想

10.4.1　线程池的需求分析

10.4.2　生产者/消费者模型的设计

10.4.3　任务拒绝策略

10.4.4　非核心线程的回收

10.4.5　线程池设计总结

10.5　从实现原理了解线程池

10.6　线程池核心源码剖析

10.6.1　线程状态和数量存储

10.6.2　线程池的状态机及变更

10.6.3　从execute()方法分析线程池源码

10.7　合理设置线程池参数

10.7.1　线程池大小的合理设置

10.7.2　动态设置线程池参数

10.8　线程池的监控

10.8.1　线程池监控的基本原理

10.8.2　在Spring Boot应用中发布线程池信息

10.9　本章小结

第11章　Java并发编程中的异步编程特性

11.1　了解Future/Callable

11.2 Future/Callable的实现原理

11.2.1　FutureTask的核心属性

11.2.2　FutureTask.run()

11.2.3　FutureTask.get()

11.2.4　finishCompletion()

11.3　Java 8新特性之CompletableFuture

11.3.1　CompletableFuture类关系图

11.3.2　CompletableFuture方法说明

11.3.3　主动获取执行结果

11.4　CompletionStage方法及作用说明

11.4.1　方法分类概述

11.4.2　CompletionStage异常处理方法

11.4.3　方法类型总结

11.5　CompletableFuture综合实战

11.5.1　商品实体对象

11.5.2　模拟微服务请求实现类

11.5.3　Web请求

11.6　CompletableFuture实现原理分析

11.6.1　Completion说明

11.6.2　图解Completion的栈结构

11.7　核心源码分析

11.7.1　CompletableFuture静态任务创建

11.7.2 Completion Stack构建

11.7.3　简述UniCompletion

11.7.4　任务执行流程

11.7.5　获取任务执行结果

11.8　本章小结