Java 语言规范中的可变示例返回令人惊讶的行为

Question

我想亲自尝试Java lang spec example，但显然有些东西我不明白。我的理解是 volatile 计数器的递增顺序应该与代码中显示的顺序相同。 “令人惊讶的是”我得到一个随机计数器值，因为一个计数器有时小于、等于和大于另一个。 有没有人可以解释我错过了什么？

下面的代码和输出：

public class C {

private static volatile int i = 0;
private static volatile int j = 0;

static void one() {
    i++;
    j++;
}

static void two() {
    int a = i;
    int b = j;
    if(a < b)
        System.out.println(a + " < " + b);
    if(a > b)
        System.out.println(a + " > " + b);
    if(a == b)
        System.out.println(a + " = " + b);
}

public static void main(String[] args) throws Exception {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            while(true)
                one();
        }
    });
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            while(true)
                two();
        }
    });

    t1.start();
    t2.start();

    Thread.sleep(5000);

    System.exit(0);
}
}

输出

214559700 > 214559699
214559807 > 214559806
214559917 > 214559916
214560019 = 214560019
214560137 > 214560136
214560247 = 214560247
214560349 > 214560348
214560455 = 214560455
214560561 > 214560560
214560670 = 214560670
214560776 = 214560776
214560886 > 214560885
214560995 = 214560995
214561097 < 214561098

Answer 1

对于所有这三种情况，假设我们从i = 0 和j = 0 开始... one() 和 two() 都可以执行两个操作，但是 1 和 2 之间的顺序是不确定的：

a == b

two() loads i (a = 0)
two() loads j (b = 0)
one() increments i (i = 1)
one() increments j (j = 1)

a > b

one() increments i (i = 1)
two() loads i (a = 1)
two() loads j (b = 0)
one() increments j (j = 1)

a （较罕见）

two() loads i (a = 0)
one() increments i (i = 1)
one() increments j (j = 1)
two() loads j (b = 1)

Answer 2

对 i 和 j 的访问是不同步的，所以，以下所有情况都可能发生：

• t2 读取 i，t2 读取 j，t1 写入 i，t1 写入 j
• t2 读取 i，t1 写入 i，t2 读取 j，t1 写入 j
• t1 写入 i，t2 读取 i，t2 读取 j，t1 写入 j
• t1 写入 i，t2 读取 i，t2 读取 j，t2 读取 i，t2 读取 j，t1 写入 j
• 等。等

Answer 3

当其中一个线程刚刚完成递增i并想要开始递增j时，另一个线程可能已经设置了int的a和b，从而导致不同的值。

volatile 与我认为您认为的用途不同。本质上，volatile 用于指示变量的值将被不同的线程修改。 volatile 修饰符保证任何读取字段的线程都会看到最近写入的值

声明一个 volatile Java 变量意味着：

• 这个变量的值永远不会被缓存在线程本地：所有的读写都将直接进入“主内存”；
• 对变量的访问就像它被包含在 synchronized 块中一样，在自身上同步。

Source and more explanation.

当您想从不同的线程而不是不同的成员访问相同的 volatile 成员时，volatile 的使用变得更加清晰。

Answer 4

请务必注意，线程可以以多种方式交错。由于您将i 和j 复制到a 和b，您可以对i 和j 进行修改在 复制i 到a 和j 变成 b。例如，这种跟踪可以解释您的输出：

一些初始状态，然后复制

• 背景：i == 214559700, j == 214559699

• T2: a = i, b = j

  214559700 > 214559699
  

递增 7 次，然后递增——复制！ ——精神

• T1: (i++ j++) (x7)
• T1: i++

• T2: a = i, b = j

    214559807 > 214559806
  

• T1: j++

递增 9 次，然后递增——复制！ ——精神

• T1: (i++ j++) (x9)
• T1: i++

• T2: a = i, b = j

  214559917 > 214559916
  

• T1: j++

递增2次，然后复制

• T1: (i++ j++) (x2)

• T2: a = i, b = j

  214560019 = 214560019
  

Answer 5

如果我们先阅读j，

static void two() {
    int b = j;
    int a = i;

那么保证a>=b。