volatile可见性和指令重排

volatile关键字的2个作用

1.线程的可见性

2.防止指令重排

什么是线程的可见性？

线程的可见性就是一个线程对一个变量进行更改操作其他线程获取会获得最新的值。

线程在执行的行操作主线程的变量。会将变量的副本拷贝一份到线程的工作区域(避免每次到主线程读取提高效率)，在更改后的一段时间内写入主内存

如下示例代码：

public class Accounting implements Runnable {
     boolean quit=false;
     int i=0;
    @Override
    public void run() {
        while (!quit){
            i++;
        }
        System.out.println("线程退出");
    }
    public static void main(String[] args) throws InterruptedException {
        Accounting accounting = new Accounting();
        Thread a1 = new Thread(accounting, "a1");
        Thread a2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("开始通知线程结束");
                    accounting.setQuit(true);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        a2.start();
        a1.start();
        Thread.sleep(1000);
    }

    public boolean isQuit() {
        return quit;
    }

    public void setQuit(boolean quit) {
        this.quit = quit;
    }
}

这段代码的逻辑就是线程a1 执行循环操作 a2 2秒后设置quit为true任务结束打印 "线程退出"；

那么真的能够成功退出吗？我们看看线程执行在内存中的操作图

打印：

开始通知线程结束

a2 线程首先将自己工作线程的quit改为ture ，然后一定时间之后去将主内存的quit改为true ，但是a1线程始终是操作的是自己的工作内存的副本所以死循环

这个时候在quit加上volatile关键字

  volatile boolean quit=false;

打印

开始通知线程结束
线程退出

加上volatile关键字后。当一个线程对变量进行修改会更新自己的工作内存里面的值，然后立即将改动的值刷新到主内存，同时线程2的工作内存的quit副本缓存失效下次直接到主内存读取所以能够正常执行

记录一个小插曲

System.out.println，sychronized，Thread.sleep Thread.sleep 影响可见性？

System.out.println

public class Accounting implements Runnable {
     boolean quit=false;
     int i=0;
    @Override
    public void run() {
        
        while (!quit){
            i++;
            System.out.println(i);
        }
        System.out.println("线程退出");
    }
    public static void main(String[] args) throws InterruptedException {
        Accounting accounting = new Accounting();
        Thread a1 = new Thread(accounting, "a1");
        Thread a2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                    System.out.println("开始通知线程结束");
                    accounting.setQuit(true);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        a2.start();
        a1.start();
        Thread.sleep(1000);


    }

    public boolean isQuit() {
        return quit;
    }

    public void setQuit(boolean quit) {
        this.quit = quit;
    }

会发现没有加上volatile一样可以成功退出。那我们上面说的线程的内存处理不成立了吗？

查资料说是因为jvm对锁的优化。因为如果我们在循环里面加上sychronize同步锁会产生大量的锁竞争所以jvm优化过后

   synchronized (this){
            while (!quit){
              //.....
            }
        }

但是我们并没有在while里面加锁啊。我们看看打印的方法源码

    public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

sleep方法并没有加锁，为什么能够保证可见性

sleep是阻塞线程并不释放锁，让出cpu调度。让出cpu调度后下次执行会刷新工作内存

指令重排

指令重排指在编译的时候，在不单线程运行不影响结果的情况下进行指令优化

如：

public class Context {
    boolean isLoad=false;
    Object configuration=null;
    public void   loadConfiguration(){
        System.out.println("正在加载配置文件");
        configuration=  new Object();
        isLoad=true;
    }

    public void  initContext(){
        System.out.println("正在进行初始化");
    }

    public static void main(String[] args) {
       Context context=new Context();
       context.loadConfiguration();
       if(context.isLoad){
           context.initContext();
       }
    }
}

这段代码就是先加载配置文件信息然后初始化上下文

我们在单线程下把他们的顺序调换模拟指令重排会对结果没有影响

  public void   loadConfiguration(){
        isLoad=true;
        System.out.println("正在加载配置文件");
        configuration=  new Object();
       
    }

但是在多线程下面

public class Context {
     boolean isLoad=false;
    Object configuration=null;
    public void   loadConfiguration(){
        //模拟jvm指令重排 将isLoad命令排在第一位
        isLoad=true;
        /***
         * 模拟并发情况下指令重排。导致的isload=true排到前面。
         * 这个时候配置文件没初始化。initContext监听到lsLoad等于true根据配置文件进行初始化
         */
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        configuration=  new Object();
        //isLoad=true;指令重排前
    }

    public void  initContext(){
        configuration.toString();
        System.out.println("正在进行初始化");
    }

    public static void main(String[] args) {
        Context context=new Context();
        //负责监听 如果加载完毕 则进行上下午初始化
        Thread t2=new Thread(new Runnable() {
            @Override
            public void run() {

                    while (true){
                        if(context.isLoad){
                            context.initContext();
                            break;
                        }
                    }


            }
        },"t2");
        //负责加载配置文件
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                context.loadConfiguration();
            }
        },"t1");
        t1.start();
        t2.start();
    }
}

只是模拟指令重排先不考虑可见性这种情况会初始化context 没有configuration 报错使用volatile关键字修饰可以避免

值得注意的一点

volatile虽然能够保证线程的可见性但是并不能保证原子性比如i++操作都是读出i的值进行运算再写入。如果在读出的时候别的线程改变了就会不一致

哪种场景适合用volatile 对一个变量的值进行修改不依赖其他值。比如 index=true 而不是i=i+j;或则index=j>a 或 a=j （会从内存中读出j的值然后赋值到a）;

java提供atomic cas能够性能比锁高能够保证原子性如：atomicInt atomictDouble

posted @ 2018-04-04 18:33 意犹未尽阅读(3592) 评论(3) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

意犹未尽

只要在学习，则在进步。