何谓线程安全？如何实现线程安全？

本文译自，如有兴趣可查看原文：https://www.baeldung.com/java-thread-safety

1.总览

Java支持开箱即用的多线程功能。这意味着，JVM可在多个线程间，同时运行字节码，提升应用性能。

多线程虽功能强大，但凡事均有代价：在多线程环境下，我们需实现“线程安全”的代码。这就是说，在多个线程进入同一资源时，不会产生错误行为和无法预期的后果。

这种编程方法就是所谓的“线程安全”。

该课程中，我们会讨论几种实现线程安全的方法。

2.无状态实现

多线程应用中的错误，基本源于多线程间，无法正确分享状态。

因此，我们首个实现线程安全的方法，便是使用无状态的代码。

为更好了解该方法，假设有个简单的UTIL类，其中有个静态方法，可计算某数字的阶乘。

public class MathUtils {

    public static BigInteger factorial(int number) {

        BigInteger f = new BigInteger("1");

        for (int i = 2; i <= number; i++) {

            f = f.multiply(BigInteger.valueOf(i));

        }

        return f;

    }

}

factorial() 是一个不可逆的无状态方法。在参数固定的情况下，它总是返回同一结果。

该方法既不依赖外部状态，也不需维护状态。因此它是一个线程安全的方法，可安全地被多个线程同时调用。

所有线程均可安全调用factorial()方法，获得正确的结果，而无需担心线程间干扰、方法结果被其他线程影响等问题。

3.不可变的实现

如果需要在线程之间分享状态，我们可以创建一个不可变类，使它变得线程安全。

“不可变”是一个跨语言，强大的编程概念，在Java中实现不可变非常容易。

简单地说，当实例被初始化后，其内部属性不可被修改，它就是不可变类。

在Java中，最简单的创造不可变类方法是使用private和final修饰属性，并不提供任何setter方法。

public class MessageService {

    private final String message;

    public MessageService(String message) {

        this.message = message;

    }

    // standard getter

}

MessageService 在初始化后，属性便不可变更，所以它是不可变的，也是线程安全的。

退一步说，哪怕MessageService是可变的，但各个线程均只能读取其数据，所以它也是线程安全的。

因此，不可变是实现线程安全的另一个方法。

4.使用线程专用（Thread-Local）属性

在面向对象编程中（OOP），对象通过属性维持状态，并使用一或多个方法实现其行为。

如果真的需要维持状态，我们可以让类的属性变成线程专用（Thread-Local），如此一来，类就不会在线程间分享状态。

在Thread类中定义私有的（private）的属性，即可使这些属性变为线程专用属性。

例如，我们可以在Thread类中保存一个整形列表。

public class ThreadA extends Thread {

    private final List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

    @Override

    public void run() {

        numbers.forEach(System.out::println);

    }

}

另一个类可能保存了字符串列表。

public class ThreadB extends Thread {

    private final List<String> letters = Arrays.asList("a", "b", "c", "d", "e", "f");

    @Override

    public void run() {

        letters.forEach(System.out::println);

    }

}

在以上两个实现，虽然类均含有自己的属性，但这些属性不会与其他线程共享。所以这些类是线程安全的。

同样道理，向属性分配ThreadLocal实例，也能让属性变成线程专用（thread-local）。

来看看这个叫StateHolder的类：

public class StateHolder {

    private final String state;

    // standard constructors / getter

}

使用以下方式，可简单的将之变为线程安全：

public class ThreadState {

    public static final ThreadLocal<StateHolder> statePerThread = new ThreadLocal<StateHolder>() {

        @Override

        protected StateHolder initialValue() {

            return new StateHolder("active"); 

        }

    };

    public static StateHolder getState() {

        return statePerThread.get();

    }

}

不同线程在访问ThreadLocal属性时，都会通过一个独立初始化的setter/getter方法，获得专属于自己的状态。除此以外，ThreadLocal跟普通属性没什么两样。

5.同步（Synchronized）集合

我们可以使用collections框架中的同步包装方法，让集合变得线程安全。

例如，其中一种创造线程安全的集合方法如下：

Collection<Integer> syncCollection = Collections.synchronizedCollection(new ArrayList<>());

Thread thread1 = new Thread(() -> syncCollection.addAll(Arrays.asList(1, 2, 3, 4, 5, 6)));

Thread thread2 = new Thread(() -> syncCollection.addAll(Arrays.asList(7, 8, 9, 10, 11, 12)));

thread1.start();

thread2.start();

要记住，同步集合中每个方法执行时，都会使用内在锁（我们稍后会讨论内在锁）。

这意味着，在同一时间，同一方法只能被单个线程访问，其它（想调用方法的）线程都会被堵塞，直到第一个线程解锁方法为止。

因此，这种同步访问策略会导致性能损失。

6.并发（Concurrent）集合

除了同步集合，我们还可以创建并发集合来实现线程安全。

Java提供的java.util.concurrent包里，包含了诸如ConcurrentHashMap内的几个并发集合。

Map<String,String> concurrentMap = new ConcurrentHashMap<>();

concurrentMap.put("1", "one");

concurrentMap.put("2", "two");

concurrentMap.put("3", "three");

与同步集合不同的是，并发集合通过切割数据的方法来实现线程安全（Java1.7之前，1.8已使用其他策略）。例如，在ConcurrentHashMap，不同线程，访问不同的数据碎片时会获得锁。因此，多个线程可以同时访问Map。

因为这种高级的线程访问策略，并发锁的性能比同步锁好得多。

值得一提的是，无论同步还是并发集合，都只会使集合本身变得线程安全，而非其内容。

7.原子操作对象

使用Java提供的原子操作类，同样可以实现线程安全。例如：AtomicInteger，AtomicLong，AtomicBoolean，和AtomicReference。

原子操作类让我们在不使用同步（synchronization）功能时，实现线程安全的原子操作。原子操作，即为一个整体，不可被打断的操作。

为理解原子操作类所解决的问题，请看如下Counter类：

public class Counter {

    private int counter = 0;

    public void incrementCounter() {

        counter += 1;

    }

    public int getCounter() {

        return counter;

    }

}

假设两个线程竞争资源，同时进入了incrementCounter()方法。

理论上说，counter属性的最终结果是2。但我们无法肯定——因为两个线程在同一时间执行同一代码，而累加并非原子操作。

现在使用AtomicInteger对象来创造一个线程安全的Counter类：

public class AtomicCounter {

    private final AtomicInteger counter = new AtomicInteger();

    public void incrementCounter() {

        counter.incrementAndGet();

    }

    public int getCounter() {

        return counter.get();

    }

}

因为incrementAndGet 是原子操作，所以它变得线程安全。

8.同步（Synchronized）方法

前面的解决方案十分适用于集合和原始类型，但有时，我们也需要控制更多功能。

因此，我们实现线程安全的另一个普通手段，就是使用同步方法。

同步方法的原理为，同一时间，只让一个线程进入方法，阻塞其他意图进入方法的线程，直到第一个线程执行完毕或抛错为止。

我们使用synchronized修饰方法，创建另一个线程安全的incrementCounter()。

public synchronized void incrementCounter() {

    counter += 1;

}

因为同一时间只能有一个线程进入方法，所以不会发生诸如并行执行的问题。

同步方法依赖“内在锁”或“监听锁（monitor locks）”实现线程安全，内在锁，是一种与某个关联实例的隐式内部实体。

多线程环境下，“监听”一词，指的是对关联实例的上锁行为，该行为会确保特定方法/代码的独家访问权。

当一个线程调用同步方法，它就会获得内在锁。执行完毕后，它就会释放锁，允许其他线程获得锁并进入方法。

我们可以在实例方法、静态方法和代码块中使用同步功能。

9.同步代码块

有时，我们仅需一部分代码实现线程安全。在这个前提下，同步整个方法，未免铺张浪费。

例如，我们来重写incrementCounter()：

public void incrementCounter() {

    // 其他无需同步的操作

    synchronized(this) {

        counter += 1; 

    }

}

例子很简单，但它展示了创建同步代码块的原理。假设该方法有一些额外的、不需同步的业务，那我们只需用synchronized块包住需要同步的代码即可。

与同步方法不同，同步代码块需要指定内在锁锁定的对象，通常用this即可。

同步是一种昂贵的操作，如果非要使用，可以只同步必须部分。

同步方法和同步代码块，可有效解决线程间的变量可视度问题。即便如此，普通类中的值有可能被CPU缓存。因此，即使使用同步技术，在变量被改变后，其它线程也有可能，无法获取最新的变量值。

我们使用volatile防止这种情况出现：

public class Counter {

    private volatile int counter;

    // 标准的构造方法/getter

}

volatile关键字告诉JVM和编译器，把counter变量存放在主内存中。这样有效保证JVM每次都会从/向主内存读取/写入counter变量，而非CPU缓存。

使用volatile，确保了对某个线程可见的所有变量，均是从主内存读取而来。

public class User {

    private String name;

    private volatile int age;

    // 标准的构造方法/getter

}

以上例子里，JVM不仅会向主内存写入age变量，还会写入name变量到主内存。这样保证了两个变量的最新数值都保存在主内存中，更新变量的结果对其他线程均可见。

相似的，如果某个线程读取了volatile变量中的值，所有对该线程可见的变量，都会从主内存中读取数值。

volatile提供的这个特性，被称为一变量volatile，全员走内存（full volatile visibility guarantee）。

11.外在锁

我们可以使用外在锁（而非内在锁），稍微改进一下Counter类中的线程安全实现。

外在锁同样保证了多线程环境下，共享资源的访问问题，不同的是，它使用了外在实体来对排他性访问进行上锁。

public class ExtrinsicLockCounter {

    private int counter = 0;

    private final Object lock = new Object();

    public void incrementCounter() {

        synchronized(lock) {

            counter += 1;

        }

    }

    // 标准的getter

}

我们使用一个普通的Object创造了外在锁，这种实现增加了锁的安全性，比前一种实现稍微好点。

使用内在锁时，synchronized方法和代码块依赖this引用，攻击者可以获得内在锁，然后触发DoS（denial of service）状态，引发死锁。

与内在锁不同的是，外在锁使用了私有实体，无法从外度获取。这加大了攻击者获得锁并引发死锁的难度。

12.可重入锁

Java提供了一系列改进的锁功能，它们的行为，比上面讨论的内在锁要稍微复杂一些。

内在锁的获取/释放机制相当死板：一个线程获得锁，开始执行方法或代码块，最终，锁会被释放，然后被其他线程获取。

内在锁并没有机制去为线程排队，为等待时间最长的线程提供优先权。

可重入锁提供了这些功能，避免等待的线程出现资源饥荒。

public class ReentrantLockCounter {

    private int counter;

    private final ReentrantLock reLock = new ReentrantLock(true);

    public void incrementCounter() {

        reLock.lock();

        try {

            counter += 1;

        } finally {

            reLock.unlock();

        }

    }

    // 标准的构造方法/getter

}

在初始化可重入锁时，能传入一个布尔值参数，表示是否实现公平分配。当设为true时，JVM会为等待时间最长的线程提供优先权。

13.读/写锁

另一个可以实现线程安全的强大机制就是读/写锁。

读写锁是一对关联的锁，一个负责只读操作，另一个负责写操作。

因此，只要没线程写入资源，就可以实现多个线程同时访问资源。在线程写入资源时，会防止其他线程读取资源。

可以像下例那样使用读写锁：

public class ReentrantReadWriteLockCounter {

    private int counter;

    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    private final Lock readLock = rwLock.readLock();

    private final Lock writeLock = rwLock.writeLock();

    public void incrementCounter() {

        writeLock.lock();

        try {

            counter += 1;

        } finally {

            writeLock.unlock();

        }

    }

    public int getCounter() {

        readLock.lock();

        try {

            return counter;

        } finally {

            readLock.unlock();

        }

    }

   // 标准的构造方法

}

14.结论

在这篇文章中，我们学习了Java的线程安全，并展示了不同的实现方法。