线程安全在Java中意味着什么？

Java中的线程安全意味着类的方法要么是原子的，要么是静态的。那么原子和静止意味着什么？为什么Java中没有其他类型的线程安全方法？

“原子”是什么意思？

当方法调用显示立即生效时，方法是原子的。因此，其他线程可以在方法调用之前或之后看到状态，但没有看到中间状态。让我们看一看非原子方法，看看原子方法是如何使类线程安全的。您可以从以下所有示例下载源代码GitHub.

public class UniqueIdNotAtomic { private volatile long counter = 0; public long nextId() { return counter++; } }

全班UniqueIdNotAtomic使用易失变量计数器创建唯一ID。我使用了一个易失性字段第2行，以确保线程始终看到当前值，要查看这个类是否线程安全，我们使用以下测试：

public class TestUniqueIdNotAtomic { private final UniqueIdNotAtomic uniqueId = new UniqueIdNotAtomic(); private long firstId; private long secondId; private void updateFirstId() { firstId = uniqueId.nextId(); } private void updateSecondId() { secondId = uniqueId.nextId(); } @Test public void testUniqueId() throws InterruptedException { try (AllInterleavings allInterleavings = new AllInterleavings("TestUniqueIdNotAtomic");) { while(allInterleavings.hasNext()) { Thread first = new Thread( () -> { updateFirstId(); } ) ; Thread second = new Thread( () -> { updateSecondId(); } ) ; first.start(); second.start(); first.join(); second.join(); assertTrue( firstId != secondId ); } } } }

为了测试计数器是否是线程安全的，我们需要两个线程，在第16和17行中创建。我们启动这两个线程，第18行和第19行。然后，我们等待使用线程连接(第20和第21行)来结束这两个线程。在两个线程停止后，我们检查这两个ID是否是唯一的，如第22行所示。

为了测试所有线程交织，我们将完整的测试放在一个while循环中，使用这个类对所有线程交织进行迭代。AllInterleavings从…vm透镜，第15行。

运行测试时，我们会看到以下错误：

`java.lang.AssertionError: at org.junit.Assert.fail(Assert.java:91) at org.junit.Assert.assertTrue`

造成此错误的原因是，由于操作++不是原子操作，这两个线程可以覆盖另一个线程的结果。我们可以从vm透镜的报告中看到这一点：

在出现错误的情况下，两个线程首先并行读取变量计数器。然后，两者创建相同的id。为了解决这个问题，我们通过使用同步块使该方法具有原子性：

private final Object LOCK = new Object(); public long nextId() { synchronized(LOCK) { return counter++; } }

现在，方法是原子化的。同步块确保其他线程无法看到方法的中间状态。

不访问共享状态的方法是自动原子化的。对于具有只读状态的类也是如此。因此，无状态和不可变类是实现线程安全类的简单方法。它们的所有方法都是自动原子化的。

并不是所有原子方法的使用都是自动线程安全的。为相同值组合多个原子方法通常会导致争用条件。让我们看看原子方法ConcurrentHashMap看看为什么。当以前的映射不存在时，让我们使用这些方法在映射中插入一个值：

public class TestUpdateTwoAtomicMethods { public void update(ConcurrentHashMap<Integer,Integer> map) { Integer result = map.get(1); if( result == null ) { map.put(1, 1); } else { map.put(1, result + 1 ); } } @Test public void testUpdate() throws InterruptedException { try (AllInterleavings allInterleavings = new AllInterleavings("TestUpdateTwoAtomicMethods");) { while(allInterleavings.hasNext()) { final ConcurrentHashMap<Integer,Integer> map = new ConcurrentHashMap<Integer,Integer>(); Thread first = new Thread( () -> { update(map); } ) ; Thread second = new Thread( () -> { update(map); } ) ; first.start(); second.start(); first.join(); second.join(); assertEquals( 2 , map.get(1).intValue() ); } } } }

该测试与以前的测试相似。同样，我们使用两个线程来测试我们的方法是否是线程安全的，第18和第19行。运行测试时，我们会看到以下错误：

java.lang.AssertionError: expected:<2> but was:<1> at org.junit.Assert.fail(Assert.java:91) at org.junit.Assert.failNotEquals(Assert.java:645)

造成这一错误的原因是，GET和PUT这两种原子方法的组合并不是原子的。因此，这两个线程可以覆盖另一个线程的结果。我们可以从vm透镜的报告中看到这一点：

在出现错误的情况下，两个线程首先并行地获得值。然后，两者都创造了相同的价值，并将其应用到地图中。要解决这个竞赛条件，我们需要使用一种方法而不是两种方法。在我们的例子中，我们可以使用单个方法计算代替这两个方法，get和put：

public void update() { map.compute(1, (key, value) -> { if (value == null) { return 1; } return value + 1; }); }

这解决了竞争条件，因为方法计算是原子的。而在同一元素上运行的所有操作ConcurrentHashMap是原子的，在整个地图上操作的操作就像尺寸一样是静止的。那么，让我们看看安静意味着什么。

“安静”是什么意思？

静态意味着当我们调用静态方法时，我们需要确保当前没有其他方法正在运行。下面的示例演示如何使用ConcurrentHashMap:

ConcurrentHashMap<Integer,Integer> map = new ConcurrentHashMap<Integer,Integer>(); Thread first = new Thread(() -> { map.put(1,1);}); Thread second = new Thread(() -> { map.put(2,2);}); first.start(); second.start(); first.join(); second.join(); assertEquals( 2 , map.size());

通过等待直到所有线程都使用线程连接完成，我们确保没有其他线程正在访问ConcurrentHashMap当我们调用方法的大小时。

方法大小使用了类中也使用的机制。java.util.concurrent.atomic.LongAdder, LongAccumulator, DoubleAdder，和DoubleAccumulator以避免争论。它使用数组，而不是使用单个变量来存储当前大小。不同的线程更新数组的不同部分，从而避免争用。该算法将在更多内容中得到解释。

静态类和方法对于在高争用下收集统计信息非常有用。收集数据后，可以使用单个线程计算收集的统计信息。

为什么Java中没有其他线程安全方法？

在理论计算机科学中，线程安全是指数据结构满足正确性标准。最常用的正确性准则是线性化的，这意味着数据结构的方法是原子的。

有关常见的数据结构存在可证明的线性化并发数据结构，请参阅本书。Maurice Herlihy和Nir Shavit的多处理器编程艺术…但是要使数据结构线性化，需要一种昂贵的同步机制，如比较和交换，参见本文。秩序法则：并行算法中昂贵的同步是无法消除的。了解更多。

因此，本文研究了静态等其它正确性准则。因此，我认为问题不是“为什么Java中没有其他类型的线程安全方法？”但是，Java中什么时候会有其他类型的线程安全可用呢？

结语

Java中的线程安全意味着类的方法要么是原子的，要么是静态的。当方法调用显示立即生效时，方法是原子的。静态意味着当我们调用静态方法时，我们需要确保当前没有其他方法正在运行。

目前，静态方法仅用于收集统计数据，例如ConcurrentHashMap…对于所有其他用例，都使用原子方法。让我们拭目以待，看看未来是否会带来更多类型的线程安全方法。