- [1.1 并发简史](#11-并发简史)

- [1.2 线程的优势](#12-线程的优势)

- [1.3 线程带来的风险](#13-线程带来的风险)

- [1.4 线程无处不在](#14-线程无处不在)

- [2.1 什么是线程安全性](#21-什么是线程安全性)

- [2.2 原子性](#22-原子性)

- [2.3 加锁机制](#23-加锁机制)

- [2.4 用锁来保护状态](#24-用锁来保护状态)

- [2.5 活跃性与性能](#25-活跃性与性能)

- [3.1 可见性](#31-可见性)

- [3.2 发布与逸出](#32-发布与逸出)

- [3.3 线程封闭](#33-线程封闭)

- [3.4 不变性](#34-不变性)

- [3.5 安全发布](#35-安全发布)

- [4.1 设计线程安全的类](#41-设计线程安全的类)

- [4.2 实例封闭](#42-实例封闭)

- [4.3 线程安全性的委托](#43-线程安全性的委托)

- [4.4 在现有的线程安全类中添加功能](#44-在现有的线程安全类中添加功能)

- [4.5 将同步策略文档化](#45-将同步策略文档化)

- [5.1 同步容器类](#51-同步容器类)

- [5.2 并发容器](#52-并发容器)

- [5.3 阻塞队列和生产者-消费者模式](#53-阻塞队列和生产者-消费者模式)

- [5.4 阻塞方法与中断方法](#54-阻塞方法与中断方法)

- [5.5 同步工具类](#55-同步工具类)

- [5.6 构建高效且可伸缩的结果缓存](#56-构建高效且可伸缩的结果缓存)

- [6.1 在线程中执行任务](#61-在线程中执行任务)

- [6.2 Executor 框架](#62-executor-框架)

- [6.3 找出可利用的并行性](#63-找出可利用的并行性)

- [7.1 任务取消](#71-任务取消)

- [7.2 停止基于线程的服务](#72-停止基于线程的服务)

- [7.3 处理非正常的线程终止](#73-处理非正常的线程终止)

- [7.4 JVM 关闭](#74-jvm-关闭)

- [8.1 在任务与执行策略之间的隐性耦合](#81-在任务与执行策略之间的隐性耦合)

- [8.2 设置线程池的大小](#82-设置线程池的大小)

- [8.3 配置 ThreadPoolExecutor](#83-配置-threadpoolexecutor)

- [8.4 扩展 ThreadPoolExecutor](#84-扩展-threadpoolexecutor)

- [8.5 递归算法的并行化](#85-递归算法的并行化)

- [10.1 死锁](#101-死锁)

- [10.2 死锁的避免与诊断](#102-死锁的避免与诊断)

- [10.3 其他活跃性危险](#103-其他活跃性危险)

- [11.1 对性能的思考](#111-对性能的思考)

- [11.2 Amdahl 定律](#112-amdahl-定律)

- [11.3 线程引入的开销](#113-线程引入的开销)

- [11.4 减少锁的竞争](#114-减少锁的竞争)

- [11.5 示例：比较 Map 的性能](#115-示例比较-map-的性能)

- [11.6 减少上下文切换的开销](#116-减少上下文切换的开销)

- [12.1 正确性测试](#121-正确性测试)

- [12.2 性能测试](#122-性能测试)

- [12.3 避免性能测试的陷阱](#123-避免性能测试的陷阱)

- [12.4 其他的测试方法](#124-其他的测试方法)

- [13.1 Lock 与 ReentrantLock](#131-lock-与-reentrantlock)

- [13.2 性能考虑因素](#132-性能考虑因素)

- [13.3 公平性](#133-公平性)

- [13.4 在 synchronized 和 ReentrantLock 之间进行选择](#134-在-synchronized-和-reentrantlock-之间进行选择)

- [13.5 读-写锁](#135-读-写锁)

- [14.1 状态依赖性的管理](#141-状态依赖性的管理)

- [14.2 使用条件队列](#142-使用条件队列)

- [14.3 显式的 Condition 对象](#143-显式的-condition-对象)

- [14.4 Synchronizer 剖析](#144-synchronizer-剖析)

- [14.5 AbstractQueuedSynchronizer](#145-abstractqueuedsynchronizer)

- [14.6 java.util.concurrent 同步器类中的 AQS](#146-javautilconcurrent-同步器类中的-aqs)

- [15.1 锁的劣势](#151-锁的劣势)

- [15.2 硬件对并发的支持](#152-硬件对并发的支持)

- [15.3 原子变量类](#153-原子变量类)

- [15.4 非阻塞算法](#154-非阻塞算法)

- [16.1 什么是内存模型，为什么需要它](#161-什么是内存模型为什么需要它)

- [16.2 发布](#162-发布)

- [16.3 初始化过程中的安全性](#163-初始化过程中的安全性)

* 在没有同步的情况下，编译器、处理器以及运行时等都可能对操作的执行顺序进行一些意想不到的调整。

* 内置锁可以用于确保某个线程以一种可预测的方式来查看另一个线程的执行结果。

* 加锁的含义不仅仅局限于互斥行为，还包括内存可见性。为了确保所有线程都能看到共享变量的最新值，所有执行读操作或者写操作的线程都必须在同一个锁上同步。

* volatile 变量是一种稍弱的同步机制。

* 当把变量声明为 volatile 类型后，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile 变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取 volatile 类型的变量时总会返回最新写入的值。

* 访问 volatile 变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此 volatile 变量是一种比 synchronized 关键字更轻量级的同步机制。

* 仅当 volatile 变量能简化代码的实现以及对同步策略的验证时，才应该使用它们。

* 加锁机制既可以确保可见性又可以确保原子性，而 volatile 变量只能确保可见性。

* 当且仅当满足以下所有条件时，才应该使用 volatile 变量

* 对变量的写入操作不依赖变量的当前值，或者你能确保只有单个线程更新变量的值。

* 该变量不会与其他状态变量一起纳入不变性条件中。

* 在访问变量时不需要加锁。

* 栈封闭：只能通过局部变量才能访问对象。

* ThreadLocal 类能使线程中的某个值与保存值得对象关联起来。ThreadLoacl 提供了 get 与 set 等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立的副本，因此 get 宗师返回由当前执行线程在调用 set 时设置的最新值。

* ThreadLocal 对象通常用于防止对可变的单实例变量或全局变量进行共享。

* 不可变对象一定是线程安全的。

* 满足以下条件的对象才是可变的：

* 对象创建以后其状态就不能修改。

* 对象的所有域都是 final 类型。

* 对象是正确创建的（在对象的创建期间，this 引用没有逸出）。

* 在没有额外的同步的情况下，任何线程都可以安全地使用被安全发布的事实不可变对象。

* 对于可变对象，不仅在发布对象时需要使用同步，并且在每次对象访问时同样需要使用同步来确保后续修改操作的可见性。

* 在并发程序中使用和共享对象时，可以使用一些实用的策略，包括：

* 线程封闭。线程封闭的对象只能由一个线程拥有，对象被封闭在该线程中，并且只能由这个线程修改。

* 只读共享。在没有额外同步的情况下，共享的只读对象可以由多个线程并发访问。

* 线程安全共享。线程安全的对象在其内部实现同步，因此多个线程可以通过对象的共有接口来进行访问而不需要进一步的同步。

* 保护对象。被保护的对象只能通过持有特定的锁来访问。保护对象包括封装在其他线程安全对象中的对象，以及已发布的并且由某个特定锁保护的对象。

* 设计线程安全类的过程中，需要包含三个基本要素：

* 找出构成对象状态的所有变量。

* 找出约束状态变量的不变性条件。

* 建立对象状态的并发访问管理策略。

* 类的不变性条件与后验条件约束力在对象上有哪些状态和状态转换是有效的。

* 将数据封装在对象内部，可以将数据的访问限制在对象的方法上，从而更易确保线程在访问数据时总能持有正确的锁。

* 封闭机制更易于构造线程安全的类，因为当封闭类的状态时，在分析类的线程安全性时就无需检查整个程序。

* 如果一个类是由多个独立且线程安全的状态变量组成，并且在所有的操作中都不包含无效状态转换，那么可以将线程安全性委托给底层的状态变量。