参考 What Volatile Means in Java，Memory Models，Consistency model。另外，stack overflow 的讨论或许有用。

Java 中的 volatile 可以保证可见性、有序性。可见性：线程 A 写入 volatile 变量，线程 B 读取该 volatile 变量可以读到最新值，并且在线程 A 写入 volatile 变量之前对 A 可见的变量值，在线程 B 读取该 volatile 变量之后对 B 也可见。有序性：禁止（编译器/CPU）对 volatile 变量相关的指令进行重排优化。虽然 Java 并发编程实战中提到 volatile 不能保证原子性，但是对 long/double 类型的 volatile 变量的简单赋值操作是原子的，我所说的简单赋值是指不依赖变量当前值的赋值操作。

问题

在《深入理解 Java 虚拟机》第 12 章中有提到 volatile 相关的汇编代码，简单的示例如下。书中提到 lock addl 相当于一个内存屏障，阻止跨内存屏障的指令重排，同时还会将当前处理器的缓存写入内存，以及使其他处理器的缓存失效，从而禁止指令重排。

1
2
3
4
5
6
7

private static boolean a;
private volatile static boolean b;

public static void foo() {
    a = true;
    b = true;
}

1
2
3
4
5

0x000002271ed4378c: movabs $0x711dec880,%r10 ; {oop(a 'java/lang/Class'{0x0000000711dec880} = 'Test')}
0x000002271ed43796: movb $0x1,0x70(%r10)
0x000002271ed4379b: movb $0x1,0x71(%r10)
0x000002271ed437a0: lock addl $0x0,-0x40(%rsp) ;*putstatic b {reexecute=0 rethrow=0 return_oop=0}
; - Test::foo@5 (line 8)

最初，我有个疑问，就是赋值语句之后的内存屏障无法禁止屏障之前的指令重排，例如此处的两个赋值语句 a=true 和 b=true 是否可能重排。询问 Jeremy（JSR-133 的作者之一）之后，他告诉我：

It is possible for processors to do that in general, but x86 doesn’t, so you don’t need a barrier there. Search for “total store order” if you’re curious.

然后，我查找和 TSO 相关的内容时，又一次找到 Russ Cox 的博客，以下内容部分来自该博客。

概念

顺序一致性（Sequential Consistency）：单个处理器按照程序顺序执行（不重排指令），多个处理器按照某种顺序交错执行，这样的多处理器就是顺序一致的。

大多数指令集架构不提供顺序一致的内存模型，因为更强的一致性通常意味着更少的优化（更低的性能）。x86 使用 Total Store Order（TSO）内存模型：所有处理器都连接到单个共享内存，但是每个处理器有一个本地的写入队列，写入操作排队写入共享内存，读取操作会优先读取本地写入队列中的值（如果有的话）。ARM/POWER 的内存模型更加宽松：每个处理器从自己的内存完整副本中读取和写入，读取可以延迟到写入之后，并且每个写入都独立地传播到其他处理器，在写入传播时允许重新排序。

测试

Litmus Test（石蕊测试）：初始时 x=0,y=0（共享变量），rn 表示私有存储（例如，寄存器或者局部变量），不考虑编译器重排指令。

以下程序是否可以看到 r1=1,r2=0？顺序一致性和 x86 中不可以，ARM/POWER 中可以。

1
2
3
4
5
6

// Thread1
x = 1
y = 1
// Thread2
r1 = y
r2 = x

以下程序是否可以看到 r1=0,r2=0？顺序一致性中不可以，x86 和 ARM/POWER 中可以。

1
2
3
4
5
6

// Thread1
x = 1
r1 = y
// Thread2
y = 1
r2 = x

其他

区分 consistency 和 coherency：consistency 表示多个处理器对所有内存位置的操作的总顺序达成一致，coherency 表示多个处理器对相同内存位置的操作的总顺序达成一致。

JMM 为程序中所有操作定义了一个偏序关系，称为 Happens-Before。操作 A Happens-Before 操作 B 的含义是：如果操作 A 先于操作 B 发生，那么执行操作 B 的线程能够看到操作 A 的结果。如果两个操作没有 Happens-Before 关系，那么 JVM/CPU 可以对它们任意地重新排序。

贴一下去年发现的 Bug，嘿嘿。

导致 Bug 的示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Main {
    public static void main(String[] args) {
        Map<Integer, Integer> map = new HashMap<>(2);

        map.merge(1, 1, Integer::sum);
        map.merge(2, 1, Integer::sum);

        map.forEach((k, v) -> {
            map.merge(k, -1, Integer::sum);
            System.out.println(k);
        });
    }
}

Java Bug DataBase 链接，里面比较详细的讨论了发生的问题，由于当时急着发出去，我的评论有点乱，而且是中文翻译为英文的，有点拉。

今天重新回顾一下 Bug，顺便简单解释一下。上述代码的输出为 2，期望输出是 2 和 1（顺序不重要）。问题在于，在两次 merge 之后，map 包含的元素数量 2 已经超过扩容阈值 1，下一次扩容发生在迭代中，导致不正确的输出。具体来说，在 resize 方法中，有 oldTab[j] = null; 操作，即转移元素到新数组时，会将旧数组的所有元素置为 null，从而旧数组的迭代器扫描不到剩余的元素。总的来说，即使在遍历的过程中，没有发生结构性的修改，在特定情况下使用 merge 方法修改 HashMap 依然会导致问题。特定情况是指，在遍历之前 HashMap 的包含的元素数量超过扩容阈值，然后在遍历的过程中使用 merge 方法。

ORACLE 的内部人员首先说明，由于调用 Map 上的方法可能产生破坏迭代的副作用，所以不建议在迭代的过程中调用 Map 上的方法，特别是具有副作用的方法，建议重写代码避免这种情况。然后提到 merge 方法确实有问题，即元素数量超过阈值也没有立即扩容，它和 put 方法的实现不同。评论中还列出其他具有类似副作用的方法，以及其他产生副作用的情况，详细看链接。

输入

Scanner 会使用正则表达式解析输入，而 BufferedReader 直接读取输入，所以 Scanner 更慢。

输出

System.out（类型为 PrintStream）的 autoFlush 属性默认为 True，所以 System.out 更慢。

模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class FastIO extends PrintWriter {
    private BufferedReader br;
    private StringTokenizer st;

    public FastIO() {
        this(System.in, System.out);
    }

    public FastIO(InputStream in, OutputStream out) {
        super(out);
        br = new BufferedReader(new InputStreamReader(in));
    }

    public FastIO(String input, String output) throws FileNotFoundException {
        super(output);
        br = new BufferedReader(new FileReader(input));
    }

    public String next() {
        try {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }
}

测试

INOUTEST - Enormous Input and Output Test