volatile的作用及应用和不适用场景

最新推荐文章于 2024-08-19 10:21:48 发布

加瓦攻城狮

最新推荐文章于 2024-08-19 10:21:48 发布

阅读量774

点赞数

分类专栏：多线程文章标签： java volatile 多线程 juc 双重加锁

本文链接：https://blog.csdn.net/Martin_JY/article/details/113482721

版权

多线程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文详细讲解了volatile关键字的作用，包括如何保证线程间可见性和防止指令重排序，通过实例说明其在单例模式和并发计数中的应用。同时，指出了volatile不适用于确保原子性的场景，并列举了不适合volatile的典型例子。

摘要由CSDN通过智能技术生成

volatile的作用

1.保证线程可见性

会将线程中变量的副本值改变后立刻写回到主内存
但是其它线程什么时候会去检查该变量是否发生变化,volatile控制不了

本质上是使用了CPU 的高速缓存一致性协议 在inter CPU下使用的是 MESI协议

2.禁止指令重排序

public class User {

   private String name;
   private Integer age;

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public Integer getAge() {
       return age;
   }

   public void setAge(Integer age) {
       this.age = age;
   }

   @Override
   public String toString() {
       return "User{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
   }
   
   public static void main(String[] args) {
       User user = new User();  
   }
}

User user = new User();
实际上有三步:
1.申请内存
2.初始化
3.赋值
加了volatile 就可以避免(在多核CPU下)产生的指令重排序

使用场景举例:

单例模式:饿汉式DLC(double lock check)

public class Singleton {

    private static volatile Singleton INSTANCE;

    private Singleton(){}

    public static Singleton getInstance(){
        if (INSTANCE == null){
            synchronized (Singleton.class){
                if (INSTANCE == null){
                    INSTANCE = new Singleton(); //实际上有三步: 申请内存 初始化 赋值
                }
            }
        }
        return INSTANCE;
    }
}

在INSTANCE = new Singleton()时,如果不加volatile,那么有可能发生指令重排序.
即申请完内存后就赋值给INSTANCE,此时INSTANCE !=null,但还未赋值
此时当另一个线程进来时if条件成立,就会重新new Singleton();
所以不安全.但发生效率极低,除非超高并发.

volatile不适用的场景

本质上是因为volatile只能保证当前线程将改变后的值写回到主内存,但无法控制其它线程什么时候去读这个改变后的值,不能保证原子性

public class VolatileNotSync {

    volatile int count = 0;  //只能保证主内存可见 但其它线程不一定能第一时间能读到这个新值

    public /*synchronized*/ void m(){
        for (int i=0;i<10000;i++){
            count ++; //非原子操作  所以必须加synchronized
        }
    }

    public static void main(String[] args) {
        VolatileNotSync volatileNotSync = new VolatileNotSync();

        List<Thread> threads = new ArrayList<>();

        for (int i=0;i<10;i++){
            threads.add(new Thread(volatileNotSync::m,"thread-"+ i));
        }

        threads.forEach((thread)->thread.start());

        threads.forEach((thread)-> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(volatileNotSync.count);  //不加synchronized 最后结果永远得不到100000
    }
}