volatile关键字

volatile关键字的两层语义：

volatile是一个轻量级的同步机制；

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

1）禁用缓存，保证内存可见性。
保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，它会保证修改的值会立即被同步更新到主存，这新值对其他线程来说是立即可见的。

2）禁止指令重排。

指令重排：处理器为了提高程序运行效率，处理器根据指令之间的数据依赖性，可能会对指令进行重排序，单线程下可以保证程序最终执行结果和代码顺序执行的结果是一致的，但是多线程下有可能出现问题。

注意：volatile关键字能保证可见性，可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

volatile应用：

①状态量标记（如上flag）

②单例模式的懒汉式
private volatile static Singleton instance = null;

详细参考：

https://zhuanlan.zhihu.com/p/138819184

https://zhuanlan.zhihu.com/p/34362413

代码验证可见性：

package com.fan.applet;
//共享的资源类
class MyData{
    /*volatile*/ int n = 0;
    public void setNto1(){
        n = 1;
    }
}
public class VolatileDemo1 {
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"进来了");
                Thread.sleep(3000);//三秒钟以后将值修改成1
                myData.setNto1();//拷贝，操作，写入到主内存
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"AA").start();

        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"进来了");
            System.out.println("BB线程拷贝的值："+myData.n);
            while (myData.n == 0){//立即看到，所以用while循环
                //线程BB一直循环，直到n的值不再等于0
            }
            System.out.println("BB线程结束");

        },"BB").start();
    }
}

验证原子性代码：

package com.fan.applet;
//共享的资源类
class MyData{
    volatile int n = 0;
    public void setNto1(){
        n = 1;
    }
    //验证原子性的方法
    public void addN(){
         n++;
    }
}
public class VolatileDemo1 {
    public static void main(String[] args) {
        MyData myData = new MyData();
        
        //验证原子性
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    myData.addN();//调用n++的方法，操作共享变量的方法
                }
            },String.valueOf(i)).start();
        }
        //等上边线程计算完，主线程获取结算结果
        while(Thread.activeCount()>2){//后台有gc和议程处理线程
            Thread.yield();//主线程出让cpu时间，主线程自己阻塞
        }
        //等10个线程计算完，调用main线程获取最终结果
        System.out.println(Thread.currentThread().getName()+"\t计算完成，总数据："+myData.n);
    }
}

案例看n++的字节码：

出现了写覆盖，导致数据的写值丢失

怎么解决volatile无原子性问题：

package com.fan.applet;

import java.util.concurrent.atomic.AtomicInteger;

//共享的资源类
class MyData{
    volatile int n = 0;
    public void setNto1(){
        n = 1;
    }
    //验证原子性的方法
    public void addN(){
         n++;
    }
    //保证原子性的方法
    AtomicInteger atomicInteger = new AtomicInteger();
    public void myAtomicAdd(){
        atomicInteger.getAndIncrement();
    }
}
public class VolatileDemo1 {
    public static void main(String[] args) {
        MyData myData = new MyData();
     

        //验证原子性
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    myData.addN();//调用n++的方法，操作共享变量的方法
                    myData.myAtomicAdd();
                }
            },String.valueOf(i)).start();
        }
        //等上边线程计算完，主线程获取结算结果
        while(Thread.activeCount()>2){//后台有gc和议程处理线程
            Thread.yield();//主线程出让cpu时间，主线程自己阻塞
        }
        //等10个线程计算完，调用main线程获取最终结果
        System.out.println(Thread.currentThread().getName()+"\t计算完成，总数据："+myData.n);
        System.out.println(Thread.currentThread().getName()+"\t原子类计算完成，总数据："+myData.atomicInteger);
    }
}

有序性：

volatile应用场景：

单例模式：

DCL:双端检索机制：



双端检锁机制加volatile：