Volatile关键字解读(四)

最新推荐文章于 2022-08-20 03:23:51 发布

溜达的地鼠

最新推荐文章于 2022-08-20 03:23:51 发布

阅读量206

点赞数

分类专栏：并发文章标签：并发

本文链接：https://blog.csdn.net/jlj417/article/details/74164086

版权

并发专栏收录该内容

9 篇文章 0 订阅

订阅专栏

volatile原理

前面讲解了一些内存相关的基础知识作为本节的一个铺垫，本节开始讲解volatile的用法

被volatile修饰的共享变量具有以下两个功能

变量可见性：一旦变量被某个线程修改，会立刻回写入内存，保证其他线程的对其可见
禁止指令重新排序

volatile可以确保可见性

以下是一个简单的例子

//线程1
boolean flag = false
while(!flag){
    doSomething();
}

//线程2
flag = true;

上面这段代码在多线程的情况下可能会出现死循环，假如线程A已经在执行while代码块，此时线程2对flag做了赋值操作，而每个线程有自己的缓存区，如果线程2的操作一直没有回写入内存，那么线程1就一直没法知道flag已经改变，会一直进行死循环。

如果增加了volatile关键字，会怎么样呢？

首先线程1中的变量在被修改后会立刻回写入内存

线程2的副本拷贝区在得知变量被修改后，会将副本的状态重置为无效

线程2在得知副本状态无效后，会从内存重新拷贝变量值，此时就能获取到最新的值

volatile不能确保原子性

首先看个例子

public class Test {
    public volatile int inc = 0;

    public void increase() {
        inc++;
    }

    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }

        //保证前面的线程都执行完 
        while(Thread.activeCount()>1)  
            Thread.yield();
        System.out.println(test.inc);
    }
}

可能大家会说这个结果是10000，但实际上最终的值小于10000，这是为什么呢？

前面在讲原子性的时候有提过自增运算有三步操作，很有可能会出现不一致的情况。假设线程1从内存中获取到变量inc的值，此时线程被阻塞了，而线程2此时也从内存中获取到变量Inc的值，因为线程1没有对变量进行修改，因此两个线程拿到的Inc的值都是10，此时线程2做自增运算，然后写入内存，紧接着线程1也对变量进行自增运算，最终Inc的结果是11而不是12。

有人会说变量被改变了不是会让副本状态无效吗？问题就在于变量改变了会让副本状态无效，而上面提到的是线程1从内存中获取到值后，线程只是被阻塞，此时变量的状态并没有被修改，所以线程2的副本不会被置为无效。

根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

为了保证原子性，可以使用以下三种方式

synchronized

public class Test {
    public  int inc = 0;

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

    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }

        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

lock

public class Test {
    public  int inc = 0;
    Lock lock = new ReentrantLock();

    public  void increase() {
        lock.lock();
        try {
            inc++;
        } finally{
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }

        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

AtomicInteger

public class Test {
    public  AtomicInteger inc = new AtomicInteger();

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

    public static void main(String[] args) {
        final Test test = new Test();
        for(int i=0;i<10;i++){
            new Thread(){
                public void run() {
                    for(int j=0;j<1000;j++)
                        test.increase();
                };
            }.start();
        }

        while(Thread.activeCount()>1)  //保证前面的线程都执行完
            Thread.yield();
        System.out.println(test.inc);
    }
}

在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作类，即对基本数据类型的自增（加1操作），自减（减1操作）、以及加法操作（加一个数），减法操作（减一个数）进行了封装，保证这些操作是原子性操作。atomic是利用CAS来实现原子性操作的（Compare And Swap），CAS实际上是利用处理器提供的CMPXCHG指令实现的，而处理器执行CMPXCHG指令是一个原子性操作。

volatile可以保证有序性

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是可见的。

　　那么我们回到前面举的一个例子：

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2

//线程2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

　　可能语句2会在语句1之前执行，那么可能导致context还没被初始化，而线程2中就使用未初始化的context去进行操作，导致程序出错。

　　这里如果用volatile关键字对inited变量进行修饰，就不会出现这种问题了，因为当执行到语句2时，必定能保证context已经初始化完毕。

volatile的原理和实现机制

　　前面讲述了源于volatile关键字的一些使用，下面我们来探讨一下volatile到底如何保证可见性和禁止指令重排序的。

　　下面这段话摘自《深入理解Java虚拟机》：

　　“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

　　lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

　　1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

　　2）它会强制将对缓存的修改操作立即写入主存；

　　3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

使用volatile关键字的场景

　　synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。通常来说，使用volatile必须具备以下2个条件：

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

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

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

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

　　下面列举几个Java中使用volatile的几个场景。

状态位的标识

volatile boolean flag = false;

while(!flag){
    doSomething();
}

public void setFlag() {
    flag = true;

double check

    /** 静态变量 */
    private static  volatile Singleton singleInstance;

    /** 私有构造方法 */
    private Singleton(){};

    /** 静态方法 */
    private static Singleton getSingleInstance(){

        /** 检查实例是否存在,不存在则进入同步区 */
        if(singleInstance == null){

            /** 第一次创建实例才会进入 */
            synchronized (Singleton.class){

                /** 再次检查,不存在则新创建实例 */
                if(singleInstance == null){

                    singleInstance = new Singleton();
                }
            }
        }
        /** 返回实例对象 */
        return singleInstance;
    }