Java多线程编程实战指南(核心篇)电子书

内容简介

前言

本书内容及特色

目标读者

本书约定

如何阅读本书

配套源码下载

与作者联系

读者服务

第一部分 多线程编程基础

第1章 走近Java世界中的线程

1.1 进程、线程与任务

1.2 多线程编程简介

1.2.1 什么是多线程编程

1.2.2 为什么使用多线程

1.3 Java线程API简介

1.3.1 线程的创建、启动与运行

1.3.2 Runnable接口

1.3.3 线程属性

1.3.4 Thread类的常用方法

1.3.5 Thread类的一些废弃方法

1.4 无处不在的线程

1.5 线程的层次关系

1.6 线程的生命周期状态

1.7 线程的监视

1.8 多线程编程简单运用实例

＊1.9 多线程编程的优势和风险

1.10 本章小结

第2章 线程编程的目标与挑战

2.1 串行、并发与并行

2.2 竞态

2.2.1 二维表分析法：解释竞态的结果

2.2.2 竞态的模式与竞态产生的条件

2.3 线程安全性

2.4 原子性

2.5 可见性

2.6 有序性

2.6.1 重排序的概念

2.6.2 指令重排序

2.6.3 存储子系统重排序

2.6.4 貌似串行语义

2.6.5 保证内存访问的顺序性

2.7 上下文切换

2.7.1 上下文切换及其产生原因

2.7.2 上下文切换的分类及具体诱因

2.7.3 上下文切换的开销和测量

2.8 线程的活性故障

2.9 资源争用与调度

2.10 本章小结

第3章 Java线程同步机制

3.1 线程同步机制简介

3.2 锁概述

3.2.1 锁的作用

3.2.2 与锁相关的几个概念

3.2.3 锁的开销及其可能导致的问题

3.3 内部锁：synchronized关键字

3.4 显式锁：Lock接口

3.4.1 显式锁的调度

3.4.2 显式锁与内部锁的比较

3.4.3 内部锁还是显式锁：锁的选用

＊3.4.4 改进型锁：读写锁

3.5 锁的适用场景

3.6 线程同步机制的底层助手：内存屏障

＊3.7 锁与重排序

3.8 轻量级同步机制：volatile关键字

3.8.1 volatile的作用

3.8.2 volatile变量的开销

3.8.3 volatile的典型应用场景与实战案例

3.9 实践：正确实现看似简单的单例模式

3.10 CAS与原子变量

3.10.1 CAS

3.10.2 原子操作工具：原子变量类

3.11 对象的发布与逸出

3.11.1 对象的初始化安全：重访final与static

3.11.2 安全发布与逸出

3.12 本章小结

第4章 牛刀小试：玩转线程

4.1 挖掘可并发点

4.2 新战场上的老武器：分而治之

4.3 基于数据的分割实现并发化

4.4 基于任务的分割实现并发化

4.4.1 按任务的资源消耗属性分割

4.4.2 实战案例的启发

4.4.3 按处理步骤分割

4.5 合理设置线程数

4.5.1 Amdahl's定律

4.5.2 线程数设置的原则

4.6 本章小结

第5章 线程间协作

5.1 等待与通知：wait/notify

5.1.1 wait/notify的作用与用法

5.1.2 wait/notify的开销及问题

5.1.3 Object.notify()/notifyAll()的选用

＊5.1.4 wait/notify与Thread.join()

5.2 Java条件变量

5.3 倒计时协调器：CountDownLatch

5.4 栅栏（CyclicBarrier）

CyclicBarrier的典型应用场景

5.5 生产者—消费者模式

5.5.1 阻塞队列

5.5.2 限购：流量控制与信号量（Semaphore）

＊5.5.3 管道：线程间的直接输出与输入

5.5.4 一手交钱，一手交货：双缓冲与Exchanger

5.5.5 一个还是一批：产品的粒度

5.5.6 再探线程与任务之间的关系

5.6 对不起，打扰一下：线程中断机制

InterruptedException异常处理及中断响应

5.7 线程停止：看似简单，实则不然

5.7.1 生产者—消费者模式中的线程停止

5.7.2 实践：Web应用中的线程停止

5.8 本章小结

第6章 保障线程安全的设计技术

＊6.1 Java运行时存储空间

6.2 大公无私：无状态对象

6.3 以“不变”应万变：不可变对象

6.4 我有我地盘：线程特有对象

6.4.1 线程特有对象可能导致的问题及其规避

6.4.2 线程特有对象的典型应用场景

6.5 装饰器模式

6.6 并发集合

6.7 本章小结

第7章 线程的活性故障

7.1 鹬蚌相争：死锁

7.1.1 死锁的检测

7.1.2 死锁产生的条件与规避

7.1.3 死锁的恢复

7.2 沉睡不醒的睡美人：锁死

7.2.1 信号丢失锁死

7.2.2 嵌套监视器锁死

7.3 巧妇难为无米之炊：线程饥饿

7.4 屡战屡败，屡败屡战：活锁

7.5 本章小结

第8章 线程管理

8.1 线程组

8.2 可靠性：线程的未捕获异常与监控

8.3 有组织有纪律：线程工厂

8.4 线程的暂挂与恢复

8.5 线程的高效利用：线程池

8.5.1 任务的处理结果、异常处理与取消

8.5.2 线程池监控

8.5.3 线程池死锁

8.5.4 工作者线程的异常终止

8.6 本章小结

第9章 Java异步编程

9.1 同步计算与异步计算

9.2 Java Executor框架

9.2.1 实用工具类Executors

9.2.2 异步任务的批量执行：CompletionService

9.3 异步计算助手：FutureTask

9.3.1 实践：实现XML文档的异步解析

9.3.2 可重复执行的异步任务

9.4 计划任务

9.5 本章小结

第10章 Java多线程程序的调试与测试

10.1 多线程程序的调试技巧

10.1.1 使用监视点

10.1.2 设置暂挂策略

10.2 多线程程序的测试

10.2.1 可测试性

10.2.2 静态检查工具：FindBugs

10.2.3 多线程程序的代码复审

10.2.4 多线程程序的单元测试：JCStress

10.3 本章小结

第二部分 多线程编程进阶

第11章 多线程编程的硬件基础与Java内存模型

11.1 填补处理器与内存之间的鸿沟：高速缓存

11.2 数据世界的交通规则：缓存一致性协议

11.3 硬件缓冲区：写缓冲器与无效化队列

11.3.1 存储转发

11.3.2 再探内存重排序

11.3.3 再探可见性

11.4 基本内存屏障

11.5 Java同步机制与内存屏障

11.5.1 volatile关键字的实现

11.5.2 synchronized关键字的实现

11.5.3 Java虚拟机对内存屏障使用的优化

11.5.4 final关键字的实现

11.6 Java内存模型

11.6.1 什么是Java内存模型

11.6.2 happen(s)-before关系

11.6.3 再探对象的安全发布

11.6.4 JSR 133

11.7 共享变量与性能

11.8 本章小结

第12章 Java多线程程序的性能调校

12.1 Java虚拟机对内部锁的优化

12.1.1 锁消除

12.1.2 锁粗化

12.1.3 偏向锁

12.1.4 适应性锁

12.2 优化对锁的使用

12.2.1 锁的开销与锁争用监视

12.2.2 使用可参数化锁

12.2.3 减小临界区的长度

12.2.4 减小锁的粒度

12.2.5 考虑锁的替代品

12.3 减少系统内耗：上下文切换

12.4 多线程编程的“三十六计”：多线程设计模式

12.5 性能的隐形杀手：伪共享

12.5.1 Java对象内存布局

12.5.2 伪共享的侦测与消除

12.6 本章小结

Web参考资源

参考文献