[Java知识库]JAVA内存模型（JMM）

介绍

Java Memory Model(Java内存模型)， 围绕着在并发过程中如何处理可见性、原子性、有序性这三个特性而建立的模型。是一种不存在的东西，是一种概念和约定。

JMM同步约定

1. 线程加锁前，必须读取到主内存共享变量的最新值。
2. 线程解锁前，必须把共享变量立刻刷新到主内存中。

主内存和本地内存

线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化之后的一个数据存放位置

JMM的三个特征

Java内存模型是围绕着并发编程中原子性、可见性、有序性这三个特征来建立的，那我们依次看一下这三个特征：

原子性

一个操作不能被打断，要么全部执行完毕，要么不执行。在这点上有点类似于事务操作，要么全部执行成功，要么回退到执行该操作之前的状态。

可见性

每个工作线程都有自己的工作内存，所以当某个线程修改完某个变量之后，在其他的线程中，未必能观察到该变量已经被修改。volatile关键字要求被修改之后的变量要求立即更新到主内存，每次使用前从主内存处进行读取。因此volatile可以保证可见性。除了volatile以外，synchronized和final也能实现可见性。synchronized保证unlock之前必须先把变量刷新回主内存。final修饰的字段在构造器中一旦完成初始化，并且构造器没有this逸出，那么其他线程就能看到final字段的值。

有序性

要保证有序性就要理解指令重排这个概念，指令重排是指在不影响结果的前提下，对代码进行优化。意思就是你写的代码计算机并不会按照你的代码去执行，而是内部去做了一系列的优化，但是结果并不会跟你的代码有差异。

volatile

保证多线程之间数据的可见性，和防止指令重排

可见性 （支持）

代码示例：

public class Futrue {

    private static int flag = 0;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (flag == 0) {
            }
        }).start();
        //让主线程休息一秒
        TimeUnit.SECONDS.sleep(2);
        
        //修改flag的值
        flag = 1;
        System.out.println(flag);


    }
}

从上面代码的运行结果可以看到当开启了一条用户线程时，当修改主线程的变量，用户线程还是一直再运行，这就表明主内存的值并没有及时通知给用户线程。当给 flag 加了volatile时，线程就会自动结束。

原子性 （不支持）

public class Futrue {

    private static final int THREADS_CONUT = 20;
    public static volatile int count = 0;

    public static void increase() {
        count++;
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(count);
    }
}

程序运行的结果发现值并不是20000 这是为什么呢？ 因为java字节码中++并不是一部操作而是多个操作，在这三步操作的时候其它线程可能修改主内存的变量。

有序性（支持）

volatile 为什么可以支持有序性，是因为volatile底层用了内存屏障这个概念 。
内存屏障：

1. 保证特定的操作顺序执行
2. 可以保证某些变量的内存可见性

AtomicInteger

AtomicInteger是一个执行++操作的原子类，底层采用CAS轻量级同步策略，保证效率的同时同时兼顾可见性、原子性、有序性。

参考volatile 原子性案例

public class Futrue {

    private static final int THREADS_CONUT = 20;
    public static AtomicInteger count = new AtomicInteger(0);

    public static void increase() {
        count.incrementAndGet();
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(count);
    }
}

由此我们可以看出AtomicInteger再没有采用重量锁的情况下也保证了原子性。