Java内存模型（JMM）是什么？JMM 通过控制主内存与每个线程的本地内存之间的交互，来提供内存可见性保证

//线程1执行的代码 
int i = 0; 
i = 10; 

//线程2执行的代码
 j = i;

int count = 0;

boolean flag = false;

count = 1;

//语句1

flag = true;

//语句2

//线程1:

init = false

context = loadContext(); //语句1

init = true; //语句2

//线程2:

while(!init){//如果初始化未完成，等待

    sleep();

}

execute(context);

//初始化完成，执行逻辑

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

execute(context)方法，而此时context并没有被初始化，就会导致程序出错。

从上面可以看出， 重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性 。 要想并发程序正确地执行，必须要保证原子性、可见性以及有序性 。只要有一个没有被保证，就有可能会导致程序运行不正确。

内存可见性

可见性： 一个线程对共享变量值的修改，能够及时的被其他线程看到

线程 A 与线程 B 之间如要通信 的话，必须要经历下面 2 个步骤：

可见性问题

案例如下：

public class Demo1Jmm {

    public static void main(String[] args) throws InterruptedException {

        JmmDemo demo = new JmmDemo();

        Thread t = new Thread(demo);

        t.start();

        Thread.sleep(100);

        demo.flag = false;

        System.out.println("已经修改为false");

        System.out.println(demo.flag);

    }

    static class JmmDemo implements Runnable {

        public boolean flag = true;

        public void run() {

            System.out.println("子线程执行。。。");

            while (flag) {

            }

            System.out.println("子线程结束。。。");

        }

    }

}

执行结果：

按照main方法的逻辑，我们已经把flag设置为false，那么从逻辑上讲，子线程就应该跳出while死循环，因为这个时候条件不成立，但是我们可以看到，程序仍旧执行中，并没有停止。

原因:线程之间的变量是不可见的，因为读取的是副本，没有及时读取到主内存结果。 解决办法： 强制线程每次读取该值的时候都去“主内存”中取值 。

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个线程执行synchronized声明的代码块（原子性）。还 可以保证共享变量的内存可见性 。同一时刻只有一个线程执行，这部分代码块的重排序也不会影响其执行结果。也就是说使用了 synchronized可以保证并发的原子性，可见性，有序性 。

JMM关于synchronized的两条规定：

线程解锁前（退出同步代码块时）：必须把自己工作内存中共享变量的最新值刷新到主内存中。

线程加锁时（进入同步代码块时）：将清空本地内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（加锁与解锁是同一把锁） 。

while (flag) {

    synchronized (this) { }

 }

public class Demo1Jmm {

    public static void main(String[] args) throws InterruptedException {

        JmmDemo demo = new JmmDemo();

        Thread t = new Thread(demo);

        t.start();

        Thread.sleep(100);  //暂停当前线程，把cpu片段让出给其他线程，减缓当前线程的执行

        demo.flag = false;

        System.out.println("已经修改为false");

        System.out.println(demo.flag);

    }

    static class JmmDemo implements Runnable {

        public boolean flag = true;

        public void run() {

            System.out.println("子线程执行。。。");

            while (flag) {

                synchronized (this) { }

            }

            System.out.println("子线程结束。。。");

        }

    }

}

public class Demo2Synchronized {

    public void test2() {

        synchronized (this) { }

    }

}

原子性：

在Java中，为了保证原子性，提供了两个高级的字节码指令 monitorenter 和 monitorexit 。这两个字节码，在Java中对应的关键字就是 synchronized 。

可见性：

Java中的 volatile 关键字提供了一个功能，那就是被其修饰的变量在被修改后可以立即同步到主内存，被其修饰的变量在每次是用之前都从主内存刷新。因此，可以使用 volatile 来保证多线程操作时变量的可见性。

除了 volatile ，Java中的 synchronized 和 final 两个关键字也可以实现可见性。只不过实现方式不同，这里不再展开了。

有序性：

在Java中，可以使用 synchronized 和 volatile 来保证多线程之间操作的有序性。实现方式有所区别： volatile 关键字会禁止指令重排。 synchronized 关键字保证同一时刻只允许一条线程操作。

好了，这里简单的介绍完了Java并发编程中解决原子性、可见性以及有序性可以使用的关键字。读者可能发现了，好像 synchronized 关键字是万能的，他可以同时满足以上三种特性，这其实也是很多人滥用 synchronized 的原因。

但是 synchronized 是比较影响性能的，虽然编译器提供了很多锁优化技术，但是也不建议过度使用。