并发三问题

重排序
内存可见性
原子性

1. 重排序

public class Test {

    private static int x = 0, y = 0;
    private static int a = 0, b =0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        for(;;) {
            i++;
            x = 0; y = 0;
            a = 0; b = 0;
            CountDownLatch latch = new CountDownLatch(1);

            Thread one = new Thread(() -> {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                }
                a = 1;
                x = b;
            });

            Thread other = new Thread(() -> {
                try {
                    latch.await();
                } catch (InterruptedException e) {
                }
                b = 1;
                y = a;
            });
            one.start();other.start();
            latch.countDown();
            one.join();other.join();

            String result = "第" + i + "次 (" + x + "," + y + "）";
            if(x == 0 && y == 0) {
                System.err.println(result);
                break;
            } else {
                System.out.println(result);
            }
        }
    }
}

观察代码可以发现，如果没有意外情况发生的话，在上下两个线程中，出现的结果应该下面三种情况

x= 0 ,y = 1; 
x= 1 ,y = 1; 
x= 1 ,y = 0;

但是在实际运行过程中，却最终有概率出现 x=0,y=0的情况。这种情况发生的原因就是出现了重排序。

重排序由一下几种机制引起：

编译器优化：对于没有数据依赖关系的操作，编译器在编译的过程中会进行一定程度的重排。
可以看到线程1中的代码，编译器是可以将a=1和x=b换一下顺序的，因为它们之间没有数据依赖关系，同理，线程2也一样，那就不难得到x==y==0的结果了。
指令重排序：CPU优化行为，也是会对不存在数据依赖关系的指令进行一定程度的重排
这个和编译器优化差不多，就算编译器不发生重排，CPU也可以对指令进行重排。
内存系统重排序：内存系统没有重排序，但是由于缓存的存在，使得程序整体上会表现出乱序的行为。
假设不发生编译器重排和指令重排，线程1修改了a的值，但是修改以后，a的值可能还没写回到主内存中，那么线程2得到a==0就是很自然的事了。同理，线程2对于b的赋值操作也可能没有及时刷新到主存中。

2.内存可见性

线程间的对于共享变量的可见性问题不是直接由多核引起的，而是由多缓存引起的。如果每个核心共享同一个缓存，那么也就不存在内存可见性问题了。 
现代多核CPU中每个核心拥有自己的一级缓存或一级缓存加上二级缓存等，问题就发生在每个核心的独占缓存上。每个核心都将会自己需要的数据读到独占缓存中，数据修改后也是写入到缓存中，然后等待刷入到主存中。所以会导致有些核心读取的值是一个过期的值。
在JMM中，抽象了主内存和本地内存的概念。
所有的共享变量存在于主内存中，每个线程有自己的本地内存，线程读写共享数据也是通过本地内存交换，所以可见性问题依然存在。这里说的本地缓存并不是真的是一块给每个线程分配的内存，而是JMM的一个抽象，是对于寄存器、一级缓存、二级缓存等的抽象。

3.原子性

对于long和double，它们的值都需要占用64位的内存空间，Java编程语言规范中提到，对于64位的值的写入，可以分为两个32位的操作进行写入。本来一个整体的赋值操作，将被拆分为低32位赋值和高32位赋值两个操作，中间如果发生了其他线程对于这个值的读操作，必然会读到一个奇怪的值。
这个时候我们需要使用volatile关键字进行控制了，JMM规定了对于volatile long 和volatile double，JVM需要保证写入操作的原子性。
另外，对于引用的读写操作始终是原子的，不管是32位的机器还是64位的机器。
Java编程规范同样提到，鼓励JVM的开发者能保证64位值操作的原子性，也鼓励使用尽量使用volatile或使用正确的同步方式。关键词是“鼓励”。
在64位JVM中，不加volatile也是可以的，同样能保证对于long和double写操作的原子性。