封面《千の刃濤、桃花染の皇姫》

在同步执行不重要的时候，编译器、运行时刻和处理器会进行一些优化，虽然这些优化通常是有益的，但是有时候会有一些微妙的问题
缓存和指令重排是并发中容易出问题的优化，在 Java 和 JVM 中提供了许多方法来控制内存顺序，volatile 关键字便是其中之一

多处理器结构

计算机执行程序的时候每条指令都是在 CPU 中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于 CPU 执行速度很快，而从内存读取数据和向内存写入数据的过程跟 CPU 执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在 CPU 里面就有了高速缓存。

当程序在运行过程中，会将运算需要的数据从主存复制一份到 CPU 的高速缓存当中，那么 CPU 进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。

class SharedObj
{
   // Changes made to sharedVar in one thread
   // may not immediately reflect in other thread
   static int sharedVar = 6;
}

举个例子，假设有两个线程使用 SharedObj，如果两个线程运行在两个不同的处理器上（如下图所示），那么每个线程有一份本地的 sharedVariable 缓存。如果其中一个线程改变其变量，可能不会马上反映到主线程中，另一个线程不会注意到数据改变了，导致了数据的不一致。关于缓存一致性可以读这篇

volatile 作用

内存可见性

可见性问题主要指一个线程修改了共享变量值，而另一个线程却看不到。引起可见性问题的主要原因是每个线程拥有自己的一个高速缓存区 —— 线程工作内存。volatile 关键字能有效的解决这个问题。

让我们来看下面这个例子

public class Demo {

    static int num;

    public static void main(String[] args) {

        Thread readerThread = new Thread(() -> {
            int temp = 0;
            while (true) {
                if (temp != num) {
                    temp = num;
                    System.out.println("reader: value of num = " + num);
                }
            }
        });

        Thread writerThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                num++;
                System.out.println("writer: changed value to = " + num);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 退出程序，否则readerThread会一直等
            System.exit(0);
        });

        readerThread.start();
        writerThread.start();
    }
}

输出如下

reader: value of num = 1
writer: changed value to = 1
writer: changed value to = 2
writer: changed value to = 3
writer: changed value to = 4
writer: changed value to = 5

没加 volatile 的时候 reader 只读到 0-1 的变化。

接下来修改代码

1	volatile static int num;

输出如下

writer: changed value to = 1
reader: value of num = 1
writer: changed value to = 2
reader: value of num = 2
writer: changed value to = 3
reader: value of num = 3
writer: changed value to = 4
reader: value of num = 4
writer: changed value to = 5
reader: value of num = 5

可以看到输出 reader 可以读到 num 的变化，volatile 指示编译器，这个变量是共享的且不稳定，每次要到主程序中读取。

禁止指令重排

一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的

int a = 10;    //语句1
int r = 2;    //语句2
a = a + 3;    //语句3
r = a*a;     //语句4

这段代码有 4 个语句，那么可能的一个执行顺序是：

但是执行顺序不可能是：语句 2 - 语句 1 - 语句 4 - 语句 3。因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令 Instruction 2 必须用到 Instruction 1 的结果，那么处理器会保证 Instruction 1 会在 Instruction 2 之前执行。

虽然重排不影响单线程内程序执行结果，但是多线程中会有影响

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2
 
//线程2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

上面代码中，由于语句 1 和语句 2 没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程 1 执行过程中先执行语句 2，而此是线程 2 会以为初始化工作已经完成，那么就会跳出 while 循环，去执行 doSomethingwithconfig (context) 方法，而此时 context 并没有被初始化，就会导致程序出错。

在 Java 中，volatile 关键字除了可以保证变量的可见性，还有一个重要的作用就是防止 JVM 的指令重排序。如果我们将变量声明为 volatile，在对这个变量进行读写操作的时候，会通过插入特定的内存屏障的方式来禁止指令重排序。

volatile 不保证原子性

volatile 关键字保证变量的可见性，但是不保证对变量操作是原子性。

public class Demo {

    volatile static int num = 0;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for (int i=0;i<5;i++){
            threadPool.execute(()->{
                for (int j=0;j<500;j++){
                    num++;
                }
            });
        }
        // 等5秒保证执行完上面代码
        Thread.sleep(5000);
        System.out.println(num);
        threadPool.shutdown();
    }
}

以上代码按照预期应该是输出 2500，然而实际的输出结果不一定是 2500，比如 2136。
这是因为 num++ 不是原子性的，其包含三步

读取 num 的值。
对 num 加 1。
将 num 的值写回内存。

改进也很简单，使用 synchronized、Lock 或者 JUC 即可。

synchronized

public class Demo {

    volatile static int num = 0;

    public synchronized void increase(){
        num++;
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        Demo demo = new Demo();
        for (int i=0;i<5;i++){
            threadPool.execute(()->{
                for (int j=0;j<500;j++){
                    demo.increase();
                }
            });
        }
        // 等5秒保证执行完上面代码
        Thread.sleep(5000);
        System.out.println(num);
        threadPool.shutdown();
    }
}

JUC

public class Demo {

    static AtomicInteger num = new AtomicInteger(0);

    public void increase(){
        num.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        Demo demo = new Demo();
        for (int i=0;i<5;i++){
            threadPool.execute(()->{
                for (int j=0;j<500;j++){
                    demo.increase();
                }
            });
        }
        // 等5秒保证执行完上面代码
        Thread.sleep(5000);
        System.out.println(num);
        threadPool.shutdown();
    }
}

Lock

public class Demo {

    static int num = 0;

    static Lock lock = new ReentrantLock();

    public void increase(){
        lock.lock();
        num++;
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        Demo demo = new Demo();
        for (int i=0;i<5;i++){
            threadPool.execute(()->{
                for (int j=0;j<500;j++){
                    demo.increase();
                }
            });
        }
        // 等5秒保证执行完上面代码
        Thread.sleep(5000);
        System.out.println(num);
        threadPool.shutdown();
    }
}