要编写线程安全的代码，其核心在于要对状态访问操作进行管理，特别是对共享（Shared）和可变的（Mutable）状态的访问。
“共享”意味着变量可以由多个线程同时访问，而“可变”则意味着变量的值在其生命周期内可以发生变化。我们将像讨论代码那样来讨论线程安全性，但更侧重于如何防止数据在数据上发生不可控的并发访问。
当多个线程访问某个状态变量并且其中有一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。Java 中的主要同步机制是关键字 synchronized ，它提供了一种独占的加锁方式，但“同步”这个术语还包括 volatile 类型的变量，显式锁（Explicit Lock）以及原子变量。
如果当多个线程访问同一个可变的状态变量时，没有使用合适的同步，那么程序就会出现错误。有三种方式可以修复这个问题：
- 不在线程之间共享该状态变量
- 将专题图变量修改为不可变的变量
- 在访问状态变量时使用同步
如果从一开始就设计一个线程安全的类，那么比在以后再将这个类修改为线程安全的类要容易的多。
当设计线程安全的类时，良好的面向对象技术、不可修改性，以及明晰的不变性规范都能起到一定的帮助作用。
2.1 什么是线程安全性
给线程安全性给出一个确切的定义：
当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么就称为这个类时线程安全的。
在线程安全类中封装了必要的同步机制，因此客户端无须进一步采取同步措施。
示例：一个无状态的 Servlet
public class StatelessFactorizer implements Servlet {
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
BigInteger i = extractFromRequest(servletRequest);
BigInteger[] factors = factor(i);
encodeIntoResponse(servletResponse, factors)
}
}
与大多数Servlet 相同，StatelessFactorizer 是无状态的：它既不包含任何域，也不包含任何对其他类中域的引用。计算过程中的临时状态仅存在于线程栈上的局部变量中，并且只能由正在执行的线程访问。
无状态对象一定是线程安全的。
2.2 原子性
假设我们希望增加一个“命中计数器”来统计所处理的请求数量。例如下代码
public class StatelessFactorizer implements Servlet { 【皱眉脸--不要这么做】
private long count = ;
public long getCount() {
return count;
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
BigInteger i = extractFromRequest(servletRequest);
BigInteger[] factors = factor(i);
++count;
encodeIntoResponse(servletResponse, factors)
}
}
不幸的是 ++count 不是原子操作，这是一个“读取-修改-写入”的操作序列。（上一节讲的竞态条件）。
2.2.1 竞态条件
当某个计算的正确性取决于多个线程的交替执行时序时，那么就会发生竞态条件。
最常见的竞态条件类型就是“先检查后执行（Check-Then-Act）”操作，即通过一个可能失效的观测结果来决定下一步的动作。
2.2.2 实例：延迟初始化中的竞态条件
public class LazyInitRace { 【皱眉脸--不要这样做】
private UnsafeSequence instance = null;
public UnsafeSequence getInstance() {
if (instance == null) {
instance = new UnsafeSequence();
}
return instance;
}
}
存在另一种竞态条件，在“读取-修改-写入”这种操作。
2.2.3 复合操作
LazyInitRace 需要以原子方式执行（不可分割）的操作。要避免竞态条件问题，就必须在某个线程修改该变量时，通过某种方式防止其他线程使用这个变量，从而确保其他线程只能在修改操作完成之前或之后读取和修改状态，而不是在修改状态的过程中。
假定有两个操作A 和B ，如果从执行 A 的线程来看，当另一个线程执行 B 时，要么将 B 全部执行完，要么完全不执行 B，那么 A 和 B 对彼此来说就是原子的。原子操作是指：对于访问同一个状态的所有操作（包括该操作本身）来说，这个操作时一个以原子方式执行的操作。
所以，我们将介绍加锁机制，这是Java 中用于确保原子性的内置机制。使用 AtomicLong 类型的变量来统计已处理请求的数量。
public class StatelessFactorizer implements Servlet {
private AtomicLong count = new AtomicLong();
public long getCount() {
return count.get();
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
BigInteger i = extractFromRequest(servletRequest);
BigInteger[] factors = factor(i);
count.incrementAndGet();
encodeIntoResponse(servletResponse, factors);
}
}
在 java.util.concurrent.atomic包中包含了一些原子变量类，用于实现在数值和对象引用上的原子状态转换。
2.3 加锁机制
当在Servlet 中添加一个状态变量时，可以通过线程安全的对象来管理 Servlet 的状态以维护 Servlet 的线程安全性。但如果想在 Servlet 中添加更多的状态，那么是否只需要添加更多的线程安全状态变量就足够了？
假设我们希望提升 Servlet 的性能：将最近的计算结果缓存起来。看代码：
public class UnsafeCachingFactorizer implements Servlet { 【皱眉脸--不要这样做】
private final AtomicReference<BigInteger> lastNumber = new AtomicReference<>();
private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<>();
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
BigInteger i = extractFromRequest(servletRequest);
if (i.equals(lastNumber.get())) {
encodeIntoResponse(servletResponse, lastFactors.get());
} else {
BigInteger[] factors = factor(i);
lastNumber.set(i); //同步1
lastFactors.set(factors); //同步2
encodeIntoResponse(servletResponse, factors);
}
}
}
尽管这里面的原子引用本身都是线程安全的，但是 还是存在着竞态条件。同步1 和 同步2 不是原子操作，可能存在问题。
要保持状态的一致性，就需要在单个原子操作中更新所有相关的状态变量
2.3.1 内置锁
Java提供了一种内置的锁机制来支持原子性：同步代码块（Synchronized Block）。同步代码块包括两部分：一个作为锁的对象引用，一个作为由这个锁保护的代码块。静态的synchronized 方法以 Class 对象作为锁。
Java 的内置锁相当于一种互斥锁，这意味着最多只有一个线程能持有这种锁。由这个锁保护的同步代码会以原子方式执行，多个线程在执行该代码块时也不会相互干扰。
在上一个程序清单里，如果使用关键字 synchronized 来修饰 service 方法，因此在同一个时刻只有一个线程可以执行 service 方法。然而，这种方法却过于极端，因为多个客户端无法同时使用Servlet ，服务响应性非常低，无法令人接受。
2.3.2 重入
当某个线程请求一个由其他线程持有的锁时，发出请求的线程会阻塞。然而，由于内置锁是可重入的，因此如果某个线程试图获得一个由自己持有的锁，那么这个请求就会成功。
“重入” 意味着获取锁的操作的粒度是“线程”，而不是“调用”。
下面代码清单：如果内置锁不是可重入的，那么这段代码将发生死锁。
public class Widget {
public synchronized void doSomething() {
...
}
}
public class LoggingWidget extends Widget {
public synchronized void doSomething() {
System.out.println(toString() + ": calling doSomething");
super.doSomething();
}
}
2.4 用锁来保护状态
由于锁能使其保护的代码路径以串行形式来访问，因此可以通过锁来构造一些协议来实现对共享状态的独占访问。
对于可能被多个线程同时访问的可变状态变量，在访问它时都需要持有同一个锁，在这种情况下，我们称状态变量是由这个锁保护的。
每个共享的和可变的变量都应该只由一个锁来保护，从而使维护人员指导是哪一个锁。
一种常见的加锁约定是，将所有的可变状态都封装在对象内部，并通过对象的内置锁对所有访问可变状态的代码路径进行同步，使得在该对象上不会发生并发访问。
当类的不可变性条件涉及多个状态变量时，那么还有另外一个需求：在不变性条件中的每个变量都必须由同一个锁来保护
如果同步可以避免竞态条件，那么为什么不在每个方法声明时都使用同步呢？事实上，如果不加区别的滥用 synchronized ，可能导致程序中出现过多的同步。
此外，将每个方法都作为同步方法还可能导致活跃性问题（Liveness）或性能问题（Performance）。
2.5 活跃性与性能
之前有介绍对整个 service 方法进行同步，虽然这种简单且粗粒度的方法能确保线程安全性，但付出的代价却很高。我们将这种应用程序称为不良并发（Poor Concurrent）应用程序：可同时调用的数量，不仅受到可用处理资源的限制，还受到应用程序本身结构的限制。
缓存最近执行因数分解的数值 及其计算结果的 Servlet：
public class UnsafeCachingFactorizer implements Servlet {
private BigInteger lastNumber;
private BigInteger[] lastFactors;
private long hits;
private long cacheHits;
public synchronized long getHits() { return hits;}
public synchronized double getCacheHitRatio() {
return (double) cacheHits / (double) hits;
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
BigInteger i = extractFromRequest(servletRequest);
BigInteger[] factors = null;
synchronized (this) {
++hits;
if (i.equals(lastNumber)) {
++cacheHits;
factors = lastFactors.clone();
}
}
if (factors == null) {
factors = factor(i);
synchronized (this) {
lastNumber = i;
lastFactors = factors.clone();
}
}
encodeIntoResponse(servletResponse, factors);
}
}
在上面的改造后的代码 实现了在简单性（对整个方法进行同步） 与并发性（对尽可能短的代码路径进行同步）之间的平衡。在获取与释放锁等操作上都需要一定的开销，因此如果将同步代码块分解的过细，那么通常并不好，尽管这样不会破坏原子性。
通常，在简单性与性能之间存在着相互制约因素。当实现某个同步策略时，一定不要盲目地为了性能而牺牲简单性（着可能会破坏安全性）
无论是执行计算密度的操作，还是在执行某个可能阻塞的操作，如果持有锁的时间过长，那么都会带来活跃性或性能问题
当执行时间较长的计算或者可能无法快速完成的操作时（例如：网络 I/O 或控制台 I/O）,一定不要持有锁。