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