为什么我不是原子++？

为什么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();
    }
}

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

您可以将本i++应被设计和记录的参数专门用于执行原子增量，以便使用来执行非原子增量i = i + 1。但是，这将破坏Java与C和C ++之间的“文化兼容性”。同样，它会带走一个方便的表示法，这是熟悉C语言的程序员所理所当然的，它具有特殊的含义，仅在有限的情况下适用。

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

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

在某些指令集体系结构中，没有原子inc或根本没有原子inc。要在MIPS上做一个原子公司，您必须编写一个软件循环，该循环使用lland sc：负载链接和存储条件。链接加载读取单词，如果单词未更改，存储条件存储新值，否则失败（检测到该单词并导致重试）。

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

重要的是JLS（Java语言规范），而不是JVM的各种实现可能未实现某种语言功能的方式。JLS在第15.14.2节中定义了++后缀运算符，该运算符表示ia“将值1加到变量的值上，然后将总和存储回变量中”。它在任何地方都没有提到或暗示多线程或原子性。对于这些，JLS提供了易失性和同步性。此外，还有包java.util.concurrent.atomic（请参阅http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html）

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

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

线程1和2：

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

如果没有同步，则可以说线程一读取了值3并将其递增为4，但尚未将其写回。此时，上下文切换发生。线程2读取值3，将其递增，然后进行上下文切换。尽管两个线程都增加了合计值，但仍将是4-竞争条件。

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并发实践

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

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

例如，看下面的代码：

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

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

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

另一个重要原因是，由于锁定，原子地执行某件事通常会花费更多时间。在人们想要进行原子操作的极少数情况下，将所有对基元的操作花费更长的时间是愚蠢的。这就是为什么他们已经增加AtomicInteger和其他原子类的语言。

分两个步骤：

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

所以这不是原子操作。当线程1执行i ++，并且线程2执行i ++时，i的最终值可能是i + 1。

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

由程序员来同步变量。查看有关此的Oracle教程。

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

B（1969）中定义了++运算符，该运算符早于java和线程处理，只是出现了一点点。