线程安全性

线程安全性定义

当多个线程访问某个类时，不管运行环境采用何种调度方式或者这些线程将如何交替执行，并且在主调代码中不需要任何额外的同步或协同，这个类都能表现出正确的行为，那么这个类是线程安全的。

要编写线程安全的代码，其核心在于要对状态访问操作进行管理，特别是对共享的和可变的状态的访问。一般来说，对象的状态是指存储在状态变量（例如实例或静态域）中的数据，”共享“意味着变量可以由多个线程同时访问，而”可变“则意味着变量的值在其生命周期内可以发生变化。

当多个线程访问某个状态变量并且其中有一个线程执行写入操作时，必须采用同步机制来协同这些线程对变量的访问。Java中的主要同步机制是关键字synchronized，它提供了一种独占的加锁方式，同步还包括volatile类型的变量，显式锁以及原子变量。

如果当多个线程访问同一个状态变量时没有使用合适的同步，那么程序就会出现错误。有三种方式可以修复这个问题：

• 不在线程之间共享该状态变量。
• 状态变量修改为不可变的变量。
• 在访问状态变量时使用同步。

访问某个变量的代码越少，就越容易确保对变量的所有访问都实现正确同步，同时也更容易找出变量在哪些条件下被访问。当设计线程安全的类时，良好的面向对象技术，不可修改性，以及明晰的不变性规范都能起到一定的帮助作用。

原子性

假定有两个操作A和B，如果从执行A的线程来看，当另一个线程执行B时，要么B全部执行完，要么完全不执行B，那么A和B对彼此来说是原子的。原子操作是指，对于访问同一个状态的所有操作（包括操作本身）来说，这个操作是一个以原子方式执行的操作。

示例1

在没有同步的情况下统计已处理请求数量的Servlet

public class UnsafeCountingFactorizer extends GenericServlet implements Servlet {
    private long count = 0;

    public long getCount() {
        return count;
    }

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        ++count;
        encodeIntoResponse(resp, factors);
    }

}

UnsafeCountingFactorizer 不 是线程安全的。虽然++count是一种紧凑的语法，使其看上去只是一种操作，但这个操作并非原子的，因而它并不会一个不可分割的操作来执行。实际上，包包含了三个独立的操作：读取count的值，将值加1，然后将计算结果写入count。这是一个”读取---修改---写入“的操作序列，并且其结果状态依赖于之前的状态。假定计数器的初始值为9，那么在某些情况下，每个线程读到的值都为9，接着执行递增操作，并且都将计数器的值设为10.显然，这并不是我们希望看到的屋况，如果有一次递增操作丢失了，命中计数器的值就将偏差1。

示例2

使用AtomicLong类型的变量来统计已处理请求的数量

public class CountingFactorizer extends GenericServlet implements Servlet {
    private final AtomicLong count = new AtomicLong(0);

    public long getCount() { return count.get(); }

    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = factor(i);
        count.incrementAndGet();
        encodeIntoResponse(resp, factors);
    }

}

CountingFactorizer 是线程安全的，在java.util.concurrent.atomic包中包含了一些原子变量类，用于实现在数值和对象引用上的原子状态转换。通过用AtomicLong来代替long类型的计数器，能够确保所有对计数器状态的访问操作都是原子的。

加锁机制

要保持状态的一致性，就需要在单个原子操作中更新所有相关的状态变量

• 内置锁

Java提供了一种 内置的锁机制来支持原子性：同步代码块。同步代码块包含两部分：一个作i为锁的对象引用，一个作为由这个锁保护的代码块。以关键字synchronized来修饰的方法就是一种横跨整个方法体的同步代码块，其中该同步代码块的锁就是方法调用所在的对象。静态的synchronized方法以Class对象作为锁

synchronized (lock) {
// 访问或修改由锁保护的共享状态
}

每个Java对象都可以用作一个实现同步的锁，这些锁被称为内置锁或监视锁。线程在进入同步代码块之前会自动获得锁，并且在退出同步代码块时自动释放锁，而无论是通过正常的控制路径结束，不是通过代码中抛出异常退出。获得内置锁的唯一途径就是进入同这个锁保护的同步代码块或方法。

Java内置锁相当于一种互斥锁，这意味着最多只有一个线程能持有这种锁。当线程A尝试获取一个由线程B持有的锁，线程A必须等待或者阻塞，直到线程B释放这个锁。如果B永远不释放锁，那么A线程也将永远地等下去。

• 重入

当某个线程请求一个由其它线程持有的锁时，发出请求的线程就会阻塞。然而，由于内置锁是可以重入的，因此如果某个线程试图获取一个经由它自己持有的锁，那么这个请求就会成功。“重入”意味着获取锁的操作的粒度是“线程”，而不是“调用”。

示例3
如果内置锁是不可重入的，那么这段代码将发生死锁

public class Widget{
    public synchronized void doSomething(){
        ...
    }
}

public class LoggingWidget extends Widget{
    public synchronized void doSomething(){
        System.out.println(toString() + ": calling doSomething");
        super.doSomething();
    }
}

使用锁来保护状态

对于可能被多个线程同时访问的可变状态变量，在访问它时都需要持有同一个锁，而且在访问这个变量所有位置上都要使用同步，且包含仅只读访问也需要使用同步---因为共享变量的可见性，在这种情况下，我们称为状态变量是由这个锁保护的。

对于每个包含多个变量的不变性条件，其中涉及的所有变量都需要由同一个锁来保护。