Java 中 .Net 的 Interlocked 类的等价物是什么？

Question

如何在 Java 中原子地且线程安全地修改 int？

原子增量、测试和 设置等...？

Answer 1

使用AtomicInteger。

Answer 2

线程安全可以通过同步函数来实现。
将您的 int （或此类数据）包装在一个类中，该类通过同步方法提供所需的功能，例如

public class X
{
  protected int x;
  public synchronized void set( int value )
  {
    x = value;
  }
}

您还可以使用 java.util.concurrent.atomic 包，例如 AtomicInteger 或 AtomicIntegerArray

为什么这个答案不起作用

我只是想要确保指出这个答案到底有什么问题，以防有人认为 synchronized 可用于解决线程竞争效应。

| Thread A      | Thread B         | 
|---------------|------------------|
| read x (x=4)  |                  |
|               | read x (x=4)     |
| Calculate 4+1 |                  |
| EAX ← 5       |                  |
|               | Calculate 4+1    |
|               | EAX ← 5          |
| Start sync    |                  |
| {             | Start sync       |
| { x ← 5       |    wait          |
| {             |    wait          |
| End sync      |    wait          |
|               | {                | 
|               | { x ← 5          |
|               | {                | 
|               | End sync         |

操作的最终结果

x = 4;
x += 1;
x += 1;

是：x = 5 而不是 6。

volatile 关键字也存在同样的问题。 volatile 关键字并不能避免线程效应。 易失性关键字仅确保

• 在读取变量之前刷新缓存，
• 在写入值后刷新缓存。

严格来说，易失性确保内存操作不会围绕易失性变量重新排序。 这意味着您仍然遭受：

• 从 x 读取
• 写入 x 的

问题。

Answer 3

private final static AtomicInteger at = new AtomicInteger();

public void run() {
    at.set(7);
    int i = at.incrementAndGet();