JAVA并发编程：volatile关键字

本文主要为记录和整理为主，在文章最低下会附上原文链接。
把我遇到的知识点和问题梳理出来。

1.JAVA并发编程中的三个概念

1.原子性
2.可见性
3.有序性

原子性

原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。

x = 10;         //语句1
y = x;         //语句2
x++;           //语句3
x = x + 1;     //语句4

这四个语句只有语句1是原子性的
其他三句都需要先读取X变量的值，然后进行其他操作

那么在读取X变量值后都有可能发生阻塞，这时就破坏了原子性。

也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

不过这里有一点需要注意：在32位平台下，对64位数据的读取和赋值是需要通过两个操作来完成的，不能保证其原子性。但是好像在最新的JDK中，JVM已经保证对64位数据的读取和赋值也是原子性操作了。

保证原子性的方法：synchronize和Lock关键字 利用同步锁，保证一次只能一个线程对变量进行操作。

可见性

对于可见性，Java提供了volatile关键字来保证可见性。

当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

有序性

在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

下面就来具体介绍下happens-before原则（先行发生原则）：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作
锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作
volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C

下面我们来解释一下前4条规则：

对于程序次序规则来说，我的理解就是一段程序代码的执行在单个线程中看起来是有序的。注意，虽然这条规则中提到“书写在前面的操作先行发生于书写在后面的操作”，这个应该是程序看起来执行的顺序是按照代码顺序执行的，因为虚拟机可能会对程序代码进行指令重排序。虽然进行重排序，但是最终执行的结果是与程序顺序执行的结果一致的，它只会对不存在数据依赖性的指令进行重排序。因此，在单个线程中，程序执行看起来是有序执行的，这一点要注意理解。事实上，这个规则是用来保证程序在单线程中执行结果的正确性，但无法保证程序在多线程中执行的正确性。

第二条规则也比较容易理解，也就是说无论在单线程中还是多线程中，同一个锁如果出于被锁定的状态，那么必须先对锁进行了释放操作，后面才能继续进行lock操作。

第三条规则是一条比较重要的规则，也是后文将要重点讲述的内容。直观地解释就是，如果一个线程先去写一个变量，然后一个线程去进行读取，那么写入操作肯定会先行发生于读操作。

第四条规则实际上就是体现happens-before原则具备传递性。

JAVA内存模型图(JMM)

JMM内存模型

Volatile关键字的两层意思

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

Volatile关键字 能保证原子性、可见性、有序性吗？为什么？举例子说明

Volatile关键字不能保证原子性，可以保证可见性，能保证部分的有序性。

比如在多线程环境下对变量i进行自增操作，假设初始时i的值为0，那么操作后i可能为1.

这里有2种方式去理解：
1.首先A线程读取变量i，值为0 然后发生阻塞。此时线程B读取i的值也为0 然后自增操作。i=1 把i的最新值1更新到本地共享变量的副本，然后再刷新到主内存中去。然后此时再回到A线程，A线程这个时候也对自己的0值进行加1操作，然后更新回副本刷新到主存中去。此时主存中i=1。这里关键的一个点就是，当线程B进行写操作后，会使得其他线程的缓存行失效，然后其他线程就会去主存中读取最新的值，这个没错。但是 线程A在一开始的时候已经把值0从缓存行入栈到自己的栈顶了（底层的指令集的操作），也就不需要再去读取缓存行所以缓存行的失效对线程A没有作用。

2.首先A线程读取变量i，值为0 然后发生阻塞。此时线程B读取i的值也为0，然后进行自增操作值为1.然后在进行更新变量副本之前，线程B阻塞。然后回到线程A，A也进行自增然后把最新值1更新到变量副本刷新回到主内存中去。此时回到线程B，线程B继续更新变量副本然后把值刷新到主内存中去还是1.

保证可见性是对的，因为当volatile关键字修饰的变量被写操作之后。就会对缓存行失效，其他的线程再次读取都会使用到最新的值，保证了可见性。

为什么说是部分的有序性呢？
因为
1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

//x、y为非volatile变量
//flag为volatile变量
 
x = 2;        //语句1
y = 0;        //语句2
flag = true;  //语句3
x = 4;         //语句4
y = -1;       //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

volatile关键字的一些使用场景

使用volatile必须具备以下2个条件：

1）对变量的写操作不依赖于当前值

2）该变量没有包含在具有其他变量的不变式中

实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

事实上，我的理解就是上面的2个条件需要保证操作是原子性操作，才能保证使用volatile关键字的程序在并发时能够正确执行。

1.标记状态量

volatile boolean flag = false;
 
while(!flag){
    doSomething();
}
 
public void setFlag() {
    flag = true;
}

保证了执行到inited赋值为true时，Context已经初始化完成，线程2再使用的时候就不会出现错误

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

2.单例模式double check

为什么要加volatile关键字，就是为了保证instance的初始化完成之后才会被使用，以免报错。如果不使用，可能会出现，线程A先new了一个对象 分配了内存地址，但是初始化对象的工作没有完成。此时线程B进来，instance不为空。线程B持有instance然后使用的时候报错。

class Singleton{
    private volatile static Singleton instance = null;
     
    private Singleton() {
         
    }
     
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}

自增操作保证原子性的方法有哪些?

用synchronize关键字

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

用lock

public class Test {
    public  int inc = 0;
    Lock lock = new ReentrantLock();
    
    public  void increase() {
        lock.lock();
        try {
            inc++;
        } finally{
            lock.unlock();
        }
    }
}

用原子操作类

public class Test {
    public  AtomicInteger inc = new AtomicInteger();
     
    public  void increase() {
        inc.getAndIncrement();
    }
}

总结一下synchronize lock volatile 和原子性 可见性 有序性的关系

synchronize和lock能保证可见性的原因是，在释放锁之前会将对变量的修改刷新到主存当中。

原文参考链接：
Java并发编程：volatile关键字解析