基于Java内存模型：synchronized和volatile的比较

1.Java内存模型

1） Java虚拟机规范试图定义一种Java内存模型，来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。

2）Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存中和从内存中取出变量这样得底层细节。

3）Java内存模型规定了所有的变量都存储在主内存中

4)每条线程都有自己的工作内存，线程的工作内存保存了该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存的变量。

2.内存间交互操作

Java内存模型定义了以下8种原子操作，来实现一个变量从主内存拷贝到工作内存以及从工作内存同步回主内存的实现细节。

lock（锁定）：作用于主内存的变量，它把一个变量标志为一条线程独占的状态

unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放出来的变量才可以被其他线程锁定。

read：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存，以便随后的load操作。

load:作用于工作内存的变量，它把read操作的得到的变量放入工作内存的变量副本中。

use:作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要用到变量的值得字节码指令时执行这个操作。

assign(赋值):作用于工作内存的变量，它把一个从执行引擎收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。

store：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后write操作使用。

write：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。

3.原子性，可见性，有序性

原子性：由Java内存模型来直接保证的原子性变量操作包括read,load,assign,use,store和write，基本类型访问读写是具备原子性的。通俗讲，就是不可以再分为多步操作了，它是最小操作单元。例如：a=2;具有原子性，但是i++;不具有原子性。它需要这样三个步骤：1.取出i 2：计算i+1 3.计算结果写入内存。

可见性：可见是指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的。

有序性：如果在本线程内观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所以操作都是无序的。前半句是指：线程内表现为串行，后边句是指：指令重排序以及工作内存主内存同步延迟现象。

4.volatile:保证可见性，禁止指令重排序优化，但不保证原子性。

1)当一个变量定义为volatile时，它保证了此变量对所有线程可见。当在读取volatile变量时，会进行load操作（从主内存读取，放入工作内存变量中）。当对volatile变量执行写操作时，会在写入后，进行store操作（把工作内存变量更新到主内存）。所以volatile具有可见性。

2)但是volatile不保证原子性。

public class VolatileTest {
    private volatile int count = 0;
 
    public void incr() {
        count++;
    }
 
    public static void main(String[] args) {
        final VolatileTest test = new VolatileTest();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100000; i++) {
                        test.incr();
                    }
                }
            }).start();
        }
 
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(test.count);
    }
}

发起5个线程，每个线程对inc进行100000次自增操作，若果能够正确并发的话，应该输出500000，但是输出的是491783，并且每次运行，输出结果都不一样吗，几乎都低于50000.，因为inc++不是原子操作。因此，volatile不能保证原子性。

在符合以下运算场景，才使用volatile变量控制并发：

(1) 运算结果并不依赖变量的当前值，或者能够确保只有单一线程修改变量的值

(2) 变量不需要与其他的状态变量共同参与不变约束

(3) volatile变量禁止指令重排序优化。

普通变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。

5.synchronized：保证原子性，可见性，有序性（指令重排）

基于Java内存模型， synchronized执行流程：

（1）线程获得获得互斥锁

（2）清空工作内存

（3）在主内存中拷贝最新变量的副本到工作内存

（4）执行完代码

（5）将更改后的共享变量的值刷新到内存

（6）释放互斥锁

synchronized一般有两种使用方式，同步方法和同步代码块。Java虚拟机基于进入和退出Monitor对象来实现synchronized代码块同步和方法同步，但二者在字节码层面的表现略有差别。

1. synchronized同步块：JVM采用monitorenter、monitorexit两个指令来实现同步。

2. synchronized方法：对于同步方法，JVM采用ACC_SYNCHRONIZED标记符来实现同步

即synchronized通过加锁保证了原子性，可见性，有序性。

public class VolatileTest {
    private int count = 0;
 
    public synchronized void incr() {
        count++;
    }
 
    public static void main(String[] args) {
        final VolatileTest test = new VolatileTest();
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100000; i++) {
                        test.incr();
                    }
                }
            }).start();
        }
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(test.count);
    }
}

发起5个线程，每个线程对inc进行100000次自增操作，能够正确并发的话，每次都输出500000。