为什么 i++ 不是原子的？

Question

为什么i++ 在 Java 中不是原子的？

为了更深入地了解 Java，我尝试计算线程中循环的执行频率。

所以我用了一个

private static int total = 0;

在主类中。

我有两个线程。

• 线程 1：打印 System.out.println("Hello from Thread 1!");
• 线程 2：打印 System.out.println("Hello from Thread 2!");

我计算线程 1 和线程 2 打印的行数。但是线程 1 的行数 + 线程 2 的行数与打印出的总行数不匹配。

这是我的代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

    private static int total = 0;
    private static int countT1 = 0;
    private static int countT2 = 0;
    private boolean run = true;

    public Test() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        newCachedThreadPool.execute(t1);
        newCachedThreadPool.execute(t2);
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        run = false;
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println((countT1 + countT2 + " == " + total));
    }

    private Runnable t1 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT1++;
                System.out.println("Hello #" + countT1 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    private Runnable t2 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT2++;
                System.out.println("Hello #" + countT2 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    public static void main(String[] args) {
        new Test();
    }
}

Answer 1

在 JVM 中，增量涉及读取和写入，因此它不是原子的。

Answer 2

i++涉及两个操作：

1. 读取i的当前值
2. 增加值并将其分配给i

当两个线程同时对同一个变量执行i++时，它们可能都得到相同的i的当前值，然后递增并设置为i+1，所以你会得到一个增量而不是两个。

例子：

int i = 5;
Thread 1 : i++;
           // reads value 5
Thread 2 : i++;
           // reads value 5
Thread 1 : // increments i to 6
Thread 2 : // increments i to 6
           // i == 6 instead of 7

Answer 3

为什么 i++ 在 Java 中不是原子的？

让我们将增量操作分解为多个语句：

线程 1 和 2：

1. 从内存中获取总计值
2. 值加 1
3. 写回内存

如果没有同步，那么假设线程一已读取值 3 并将其增加到 4，但尚未将其写回。此时，上下文切换发生。线程二读取值 3，将其递增，然后发生上下文切换。虽然两个线程都增加了总值，但它仍然是 4 - 竞态条件。

Answer 4

并发（Thread 类等）是Java 的 v1.0 中的新增功能。 i++ 在此之前的测试版中添加了，因此它仍然很有可能在其（或多或少）原始实现中。

由程序员来同步变量。查看Oracle's tutorial on this。

编辑：澄清一下，i++ 是一个早于 Java 的定义良好的过程，因此 Java 的设计者决定保留该过程的原始功能。

++ 运算符是在 B (1969) 中定义的，它比 java 和线程早一点。

Answer 5

Java 规范

重要的是JLS (Java Language Specification)，而不是 JVM 的各种实现可能会或可能不会实现该语言的某个特性。

JLS 在第 15.14.2 条中定义了 ++ 后缀运算符，其中 i.a. “值 1 被添加到变量的值中，并且总和被存储回变量中”。它没有提到或暗示多线程或原子性。

对于多线程或原子性，JLS 提供 volatile 和 synchronized。此外，还有Atomic… 类。

Answer 6

i++ 在 Java 中可能不是原子性的，因为原子性是一个特殊要求，在 i++ 的大多数使用中都不存在。这个要求有很大的开销：使增量操作原子化的成本很高；它涉及软件和硬件级别的同步，不需要以普通增量存在。

您可以提出 i++ 应该被设计和记录为专门执行原子增量的论点，以便使用 i = i + 1 执行非原子增量。但是，这会破坏 Java、C 和 C++ 之间的“文化兼容性”。同样，它会带走熟悉类 C 语言的程序员认为理所当然的方便符号，赋予它仅在有限情况下适用的特殊含义。

for (i = 0; i < LIMIT; i++) 等基本 C 或 C++ 代码将转换为 Java 为 for (i = 0; i < LIMIT; i = i + 1)；因为使用原子i++ 是不合适的。更糟糕的是，从 C 或其他类 C 语言到 Java 的程序员无论如何都会使用i++，从而导致不必要地使用原子指令。

即使在机器指令集级别，出于性能原因，增量类型的操作通常也不是原子的。在 x86 中，必须使用特殊指令“锁定前缀”来使 inc 指令原子化：原因同上。如果inc 始终是原子的，则在需要非原子公司时永远不会使用它；程序员和编译器会生成加载、加 1 和存储的代码，因为这样会更快。

在某些指令集架构中，没有原子inc 或者根本没有inc；要在 MIPS 上进行 atomic inc，您必须编写一个使用 ll 和 sc 的软件循环：加载链接和条件存储。加载链接读取单词，如果单词没有更改，则存储条件存储新值，否则失败（检测到并导致重试）。

Answer 7

如果i++ 操作是原子操作，您将没有机会从中读取值。这正是您想要使用i++（而不是使用++i）来做的事情。

例如看下面的代码：

public static void main(final String[] args) {
    int i = 0;
    System.out.println(i++);
}

在这种情况下，我们希望输出为：0 （因为我们发布增量，例如先读取，然后更新）

这是操作不能是原子操作的原因之一，因为您需要读取值（并对其进行操作）并然后更新该值。

另一个重要的原因是原子地做某事通常会因为锁定而花费更多时间。在人们想要进行原子操作的极少数情况下，让对原语的所有操作花费更长的时间是很愚蠢的。这就是为什么他们在语言中添加了AtomicInteger 和other 原子类。

Answer 8

i++ 是一个只涉及3个操作的语句：

1. 读取当前值
2. 写入新值
3. 存储新值

这三个操作并不意味着在一个步骤中执行，或者换句话说i++ 不是一个复合 操作。因此，当多个线程参与单个但非复合操作时，各种事情都可能出错。

考虑以下场景：

时间 1：

Thread A fetches i
Thread B fetches i

时间 2：

Thread A overwrites i with a new value say -foo-
Thread B overwrites i with a new value say -bar-
Thread B stores -bar- in i

// At this time thread B seems to be more 'active'. Not only does it overwrite 
// its local copy of i but also makes it in time to store -bar- back to 
// 'main' memory (i)

时间 3：

Thread A attempts to store -foo- in memory effectively overwriting the -bar- 
value (in i) which was just stored by thread B in Time 2.

Thread B has nothing to do here. Its work was done by Time 2. However it was 
all for nothing as -bar- was eventually overwritten by another thread.

你有它。竞争条件。

---

这就是i++ 不是原子的原因。如果是这样，这一切都不会发生，每个fetch-update-store 都会自动发生。这正是 AtomicInteger 的用途，在您的情况下，它可能正好适合。

附言

一本涵盖所有这些问题的优秀书籍，其中一些是这样的： Java Concurrency in Practice

Answer 9

有两个步骤：

1. 从内存中获取 i
2. 将 i+1 设置为 i

所以它不是原子操作。 当thread1执行i++，thread2执行i++时，i的最终值可能是i+1。

Answer 10

在 JVM 或任何 VM 中，i++ 等价于以下内容：

int temp = i;     // 1. read
i = temp + 1;    // 2. increment the value then 3. write it back

这就是为什么 i++ 是非原子的。