volatile关键字详解

volatile的三个特点

1. 保证线程之间的可见性
2. 禁止指令重排
3. 不保证原子性

可见性

概念

可见性是多线程场景中才讨论的，它表示多线程环境中，当一个线程修改了共享变量的值，其他线程能够知道这个修改。

为什么需要可见性

缓存一致性问题：

public class Test {
    public static void main(String[] args) {
        Mythread mythread = new Mythread();

        new Thread(() -> {
            try {
                //延时2s,确保进入while循环
                TimeUnit.SECONDS.sleep(2);
                //num自增
                mythread.increment();
                System.out.println("Thread-" + Thread.currentThread().getName() +
                        " current num value:" + mythread.num);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "test").start();

        while(mythread.num == 0){ 
            //dead
        }

        System.out.println("game over!!!");
    }
}

class Mythread{
    //不加volatile，主线程无法得知num的值发生了改变，从而陷入死循环
    volatile int num = 0;

    public void increment(){
        ++num;
    }
}

如上述代码，如果不加volatile，程序运行结果如下

加上volatile关键字后，程序运行结果如下

解决方向：

• 总线锁：

  一次只有一个线程能通过总线进行通信。（效率低，已弃用）

• MESI缓存一致性协议，CPU总线嗅探机制（监听机制）

  有volatile修饰的共享变量在编译器编译后进行读写操作时，指令会多一个lock前缀,Lock前缀的指令在多核处理器下会引发两件事情。

  • 写一个volatile变量时，JMM（java共享内存模型）会把该线程对应的本地内存中的共享变量值刷新到主内存；

  • 当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效，线程接下来从主内存中读取共享变量。

  ---

  • 每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置为无效状态， 当处理器对这个数据进行修改操作的时候，会重新从系统内存中吧数据读到处理器缓存行里。

  • 处理器使用嗅探技术保证它的内部缓存，系统内存和其他处理器的缓存在总线上保持一致

  （参考下面两位大佬的博客）

  https://blog.csdn.net/jinjiniao1/article/details/100540277

  https://blog.csdn.net/qq_33522040/article/details/95319946

禁止指令重排

指令重排概念

编译器和CPU在保证最终结果不变的情况下，对指令的执行顺序进行重排序。

指令重排的问题

可以与双重检验实现单例模式联系起来看：

首先，一个对象的创建过程可大致分为以下三步：

1. 分配内存空间
2. 执行对象构造方法，初始化对象
3. 引用指向实例对象在堆中的地址

但是在实际执行过程中，CPU可能会对上述步骤进行优化，进行指令重排

序1->3->2，从而导致引用指向了未初始化的对象，如果这个时候另外一个线

程引用了该未初始化的对象（只执行了1->3两步），就会产生异常。

不保证原子性

为什么无法保证

具体例子

public class Test {
    public static void main(String[] args) {
        Mythread mythread = new Mythread();
        for(int i = 0; i < 6666; ++i){
            new Thread(() -> {
                try {
                    mythread.increment();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "test").start();
        }
        System.out.println("Thread-" + Thread.currentThread().getName() +
                " current num value:" + mythread.num);
    }
}

class Mythread{
    volatile int num = 0;

    public void increment(){
        ++num;
    }
}