JAVA多线程之volatile关键字

最新推荐文章于 2024-06-21 17:14:47 发布
最新推荐文章于 2024-06-21 17:14:47 发布
阅读量1k 收藏 9
点赞数 34
分类专栏： JUC 文章标签： java 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ifhuke/article/details/136870433
版权

文章目录

上次我们提到在代码中加上volatile就可以防止JVM的指令重排问题，这节我们来详细讲解一下volatile关键字。

1. volatile保证可见性

volatile 的底层实现原理是内存屏障，Memory Barrier（Memory Fence）

  • 对 volatile 变量的写指令后会加入写屏障
  • 对 volatile 变量的读指令前会加入读屏障

我们先来介绍一下读屏障和写屏障是什么。

  • 写屏障（sfence，Store Barrier）保证在该屏障之前的，对共享变量的改动，都同步到主存当中

    public void actor2(I_Result r) {
    num = 2;
    ready = true; // ready 是 volatile 赋值带写屏障
    // 写屏障
}

  • 读屏障（lfence，Load Barrier）保证在该屏障之后的，对共享变量的读取，从主存刷新变量值，加载的是主存中最新数据

    public void actor1(I_Result r) {
    // 读屏障
    // ready 是 volatile 读取值带读屏障
    if(ready) {
    	r.r1 = num + num;
    } else {
    	r.r1 = 1;
    }
}

    在这里插入图片描述

  • 全能屏障：mfence（modify/mix Barrier），兼具 sfence 和 lfence 的功能

2. volatile保证有序性

很明显，利用读屏障和写屏障也能够保障指令的有序性。

  • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后

    public void actor2(I_Result r) {
    num = 2;
    ready = true; // ready 是 volatile 赋值带写屏障
    // 写屏障
}

  • 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

    public void actor1(I_Result r) {
    // 读屏障
    // ready 是 volatile 读取值带读屏障
    if(ready) {
    	r.r1 = num + num;
    } else {
    	r.r1 = 1;
    }
}

注意：

  • 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证其他线程的读跑到写屏障之前

  • 有序性的保证也只是保证了本线程内相关代码不被重排序

3. 缓存一致

使用 volatile 修饰的共享变量，底层通过汇编 lock 前缀指令进行缓存锁定，在线程修改完共享变量后写回主存，其他的 CPU 核心上运行的线程通过 CPU 总线嗅探机制会修改其共享变量为失效状态，读取时会重新从主内存中读取最新的数据

lock 前缀指令就相当于内存屏障，Memory Barrier（Memory Fence）

  • 对 volatile 变量的写指令后会加入写屏障
  • 对 volatile 变量的读指令前会加入读屏障

内存屏障有三个作用：

  • 确保对内存的读-改-写操作原子执行
  • 阻止屏障两侧的指令重排序
  • 强制把缓存中的脏数据写回主内存，让缓存行中相应的数据失效

多线程中，因为JIT编译器优化就会导致读取不到最新的值，所以要阻止这种优化。指令重排这个前面老师又讲，这里主要是将没有讲的JVM原理结合

4. DCL问题

4.1 问题出现

DCL即Double-Checked Locking，双端检锁机制，我们咦单例模式为例看看这个问题的出现：

public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
        synchronized(Singleton.class) {
            if (INSTANCE == null) { // t1
                INSTANCE = new Singleton();
            }
        }
        return INSTANCE;
    }
}

上述代码当多线程进行访问的时候，可能会不断地尝试占用锁，这样对性能有很大的影响，于是我们可以尝试如下改进，在进入同步模块之前，首先判断 INSTANCE 变量是否是null，如果是的话，再进入同步代码块，代码如下：

public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
        if(INSTANCE == null){
            synchronized(Singleton.class) {
                if (INSTANCE == null) { // t1
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

上面的代码优化了操作，性能提高了不少，但是在多线程环境下，还是有一些问题，即DCL问题。

我们来看一下上述代码的字节码：

0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
27: aload_0
28: monitorexit
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn

我们来看最核心的，也就是产生问题的几行字节码：

  • 17 表示创建对象，将对象引用入栈 // new Singleton
  • 20 表示复制一份对象引用 // 引用地址
  • 21 表示利用一个对象引用，调用构造方法
  • 24 表示利用一个对象引用，赋值给 static INSTANCE

产生的问题依旧是JVM的重排问题。

也许 jvm 会优化为：先执行 24，再执行 21。如果两个线程 t1，t2 按如下时间序列执行：

在这里插入图片描述

关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取INSTANCE 变量的值，这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初始化完毕的单例，这就会导致其进入阻塞队列。

4.2 问题解决

可以将INSTANCE变量加一个volatile，上面的代码改为：

public final class Singleton {
    private Singleton() { }
    private static volatile Singleton INSTANCE = null;
    public static Singleton getInstance() {
        // 实例没创建，才会进入内部的 synchronized代码块
        if (INSTANCE == null) {
            synchronized (Singleton.class) { // t2
                // 也许有其它线程已经创建实例，所以再判断一次
                if (INSTANCE == null) { // t1
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

字节码上看不出来 volatile 指令的效果，我们可以根据读写屏障来进行分析：

// -------------------------------------> 加入对 INSTANCE 变量的读屏障
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter -----------------------> 保证原子性、可见性
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
// -------------------------------------> 加入对 INSTANCE 变量的写屏障
27: aload_0
28: monitorexit ------------------------> 保证原子性、可见性
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn

如上面的注释内容所示，读写 volatile 变量时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：

  • 可见性

    1. 写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
    2. 而读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据

  • 有序性

    1. 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
    2. 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

  • 更底层是读写变量时使用 lock 指令来多核 CPU 之间的可见性与有序性

流程如下：

在这里插入图片描述

注意：

  • 在synchronized中的语句是可以被JVM重排的
  • 如果变量只出现在synchronized语句中，是可以保证有序性的

4.3 问题细节

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用getInstance）时的线程安全。

  1. // 问题1：为什么加 final
// 原因：防止以后有子类创建新的实例，子类重写破坏单例，加了final就不允许被继承
// 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例
// 原因：需要加入下述代码，当反序列化时，系统会调用 readResolve() 方法，从而确保返回的是单例对象，加入下面的readResovle方法
public final class Singleton implements Serializable {
    // 问题3：为什么设置为私有? 是否能防止反射创建新的实例?
    // 原因：私有不能防止反射
    private Singleton() {}
    // 问题4：这样初始化是否能保证单例对象创建时的线程安全?
    // 原因：能，静态成员是由JVM在类加载阶段完成，该阶段由JVM保证线程安全
    private static final Singleton INSTANCE = new Singleton();
    // 问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由
    // 原因： 提供静态方法可以提供更多的控制，比如在获取单例对象时可以进行额外的处理。而直接将 INSTANCE 设置为 public 则失去了这种控制的能力。此外，静态方法也可以用来延迟实例化，即在第一次调用时再创建实例，而直接将 INSTANCE 设置为 public 则无法实现延迟加载。
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public Object readResolve() {
        return INSTANCE;
    }
}

  2. // 问题1：枚举单例是如何限制实例个数的
// 原因： 枚举类型在 Java 中保证只有一个实例的方式是 JVM 在加载枚举类的时候，会保证每个枚举值在 JVM 中只有一个实例，因此枚举类型天生就是单例的。在枚举中，每个枚举值都是枚举类型的一个实例
// 问题2：枚举单例在创建时是否有并发问题
// 原因： 枚举单例在创建时没有并发问题。因为枚举类型的实例是在类加载阶段就被创建好的，并且由 JVM 来保证线程安全
// 问题3：枚举单例能否被反射破坏单例
// 原因： 枚举单例不能被反射破坏单例。因为枚举类型的实例是在类加载的时候被创建好的，并且 JVM 保证每个枚举值在 JVM 中只有一个实例，无法通过反射创建新的实例
// 问题4：枚举单例能否被反序列化破坏单例
// 原因： 枚举单例不能被反序列化破坏单例。因为枚举类型默认实现了 Serializable 接口，同时枚举类型的序列化和反序列化由 JVM 内部处理，保证了在反序列化过程中不会创建新的实例
// 问题5：枚举单例属于懒汉式还是饿汉式
// 原因： 枚举单例属于饿汉式。因为枚举类型的实例是在类加载的时候被创建好的，无论是否被使用，都会在类加载的时候进行实例化
// 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做
// 原因： 枚举类型的实例在类加载时就被创建，所以如果需要在创建时进行初始化逻辑，可以在枚举中定义一个构造方法，并在枚举值中调用该构造方法来进行初始化，如下
enum Singleton {
    INSTANCE;

    private Singleton() {
        // 进行初始化逻辑
    }
}

  3. public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    // 分析这里的线程安全, 并说明有什么缺点
    // 使用synchronized保证了线程安全，但是锁的范围太大了
    public static synchronized Singleton getInstance() {
        if( INSTANCE != null ){
            return INSTANCE;
        }
        INSTANCE = new Singleton();
        return INSTANCE;
    }
}

  4. public final class Singleton {
    private Singleton() { }
    // 问题1：解释为什么要加 volatile ?
    // 原因： 使用volatile的读写屏障使得JVM不进行指令重排
    private static volatile Singleton INSTANCE = null;
    // 问题2：对比实现3, 说出这样做的意义
    // 原因：这种方式只在实例为 null 时才进行同步，避免了每次调用 getInstance() 方法都需要获取锁的开销
    public static Singleton getInstance() {
        if (INSTANCE != null) {
            return INSTANCE;
        }
        synchronized (Singleton.class) {
            // 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗
            // 原因： 防止指令重排导致多个线程进来
            if (INSTANCE != null) { // t2
                return INSTANCE;
            }
            INSTANCE = new Singleton();
            return INSTANCE;
        }
    }
}

  5. public final class Singleton {
        private Singleton() { }
        // 问题1：属于懒汉式还是饿汉式
    	// 原因： 属于是懒汉式，因为该对象在类加载的时候才加载，其他地方都不进行加载
        private static class LazyHolder {
            static final Singleton INSTANCE = new Singleton();
        }
        // 问题2：在创建时是否有并发问题
    	// 类加载阶段进行加载，由JVM保证线程安全，没有并发问题
        public static Singleton getInstance() {
            return LazyHolder.INSTANCE;
        }
    }

5. Balking设计模式

Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回，比如说下面的代码，多次调用 start() 方法，会产生多个监控记录，

@Slf4j(topic = "c.Test20")
public class Test1 {
    volatile static boolean run = true;	//添加volatile
    final static Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        tpt.start();
        tpt.start();

    }
}

class TwoPhaseTermination {
    // 监控线程
    private Thread monitor;
    // 停止标记
    private volatile boolean stop = false;;

    // 启动监控线程
    public void start() {
        monitor = new Thread(() -> {
            while (true) {
                Thread thread = Thread.currentThread();
                if (stop) {
                    System.out.println("后置处理");
                    break;
                }
                try {
                    Thread.sleep(1000);// 睡眠
                    System.out.println(thread.getName() + "执行监控记录");
                } catch (InterruptedException e) {
                    System.out.println("被打断，退出睡眠");
                }
            }
        });
        monitor.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true;
        monitor.interrupt();// 让线程尽快退出Timed Waiting
    }
}

多个监控记录如下：

Thread-1执行监控记录
Thread-0执行监控记录
Thread-2执行监控记录
Thread-2执行监控记录
Thread-1执行监控记录

如果想要发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回，即只创建一个新的对象，那么可以设置一个标记位用于判断是否执行过 start() 方法，如果执行过，那么直接返回，代码如下：

class TwoPhaseTermination {
    // 监控线程
    private Thread monitor;
    // 停止标记
    private volatile boolean stop = false;;
    // 判断是否执行过start方法
    private boolean starting = false;

    // 启动监控线程
    public void start() {
        // 如果启动过，就直接返回
        synchronized (this){
            if(starting){
                return;
            }
            starting = true;
        }
        
        monitor = new Thread(() -> {
            while (true) {
                Thread thread = Thread.currentThread();
                if (stop) {
                    System.out.println("后置处理");
                    break;
                }
                try {
                    Thread.sleep(1000);// 睡眠
                    System.out.println(thread.getName() + "执行监控记录");
                } catch (InterruptedException e) {
                    System.out.println("被打断，退出睡眠");
                }
            }
        });
        monitor.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true;
        monitor.interrupt();// 让线程尽快退出Timed Waiting
    }
}
Suppose-dilemma
关注
  • 34
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程：volatile关键字
流楚丶格念的博客
07-17 1283
当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题堆内存是唯一的，每一个线程都有自己的线程栈。每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。在线程中，每一次使用是从变量的副本中获取的。......
Java多线程之volatile关键字
zhangyan_1010的专栏
04-20 282
volatile关键字 Java多线程
java多线程volatile_java多线程之volatile关键字
weixin_42140846的博客
02-12 86
Java线程：volatile关键字Java™ 语言包含两种内在的同步机制：同步块(或方法)和 volatile 变量。这两种机制的提出都是为了实现代码线程的安全性。其中 Volatile 变量的同步性较差(但有时它更简单并且开销更低)，而且其使用也更容易出错。谈及到volatile关键字，不得不提的一篇文章是：《Java 理论与实践: 正确使用 Volatile 变量》，这篇文章对volatil...
Java多线程之volatile关键字和内存屏障
老胡
05-31 1742
前面一篇文章在介绍Java内存模型的三大特性(原子性、可见性、有序性)时，在可见性和有序性中都提到了volatile关键字，那这篇文章就来介绍volatile关键字的内存语义以及实现其特性的内存屏障。 volatile是JVM提供的一种最轻量级的同步机制，因为Java内存模型为volatile定义特殊的访问规则，使其可以实现Java内存模型中的两大特性：可见性和有序性。正因为volatile关键字...
java多线程之volatile关键字
java小酱油
08-05 829
在java线程并发处理中，关键字volatile的主要作用是使变量在多个线程间可见。那么volatile到底该怎么用了？我们首先来看一段代码： public class MyThread1 implements Runnable { private boolean istag = true; public boolean isIstag() { return istag; }
【Java多线程学习4】volatile关键字及其作用
weixin_43950588的博客
08-01 342
volatile关键字及其作用
JAVA多线程以及volatile关键字详解
a512512a的博客
12-29 1889
上述代码T1线程中当qiut等于0的时候一个线程在不停的循环，另外一个线程T2中写入了scanner来改变quit的值 按照理论来讲，如果我们此时输入0以外的数字，比如输入1，T1线程中拿到quit等于1然后就会跳出循环执行下面的打印方法.(此时只有一个线程在操作变量不需要使用synchronized)但是运行程序可知。原因是原来在我们编写程序的时候开发JVM虚拟机，和java等编译器的工作人员会对我们的代码，在不改变原有逻辑的基础上进行一部分的优化.以便提高代码的执行效率。所以最后结果为10w了。
JAVA多线程基础篇-关键字volatile
qq_33479841的博客
05-16 1819
1.概述 volatile是java多线程中一个常见的关键字，面试中被问的频率也比较高。那么volatile的作用是什么？以及其实现原理是什么？本文将基于上述问题，结合一些具体案例来分析volatile的作用以及实现原理，来帮助大家更好地理解volatile。 2.案例分析 ...
Java多线程-volatile关键字
qq_24095055的博客
03-14 666
文章目录volatile关键字一 简介二 volatile关键字的可见性三 volatile关键字能保证原子性吗？四 synchronized关键字和volatile关键字比较 volatile关键字 一 简介 Java中的“volatile关键字”： 在 JDK1.2 之前，Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可...
Java 多线程 --- 线程同步 volatile关键字
HelloWorld
08-07 561
volatile keyword 使用volatile保证可见性 使用volatile禁止指令重排
Java多线程之volatile关键字及内存屏障实例解析
08-25
volatile是JVM提供的一种最轻量级的同步机制，因为Java内存模型为volatile定义特殊的访问规则，使其可以实现Java内存模型中的两大特性...这篇文章主要介绍了Java多线程之volatile关键字及内存屏障,需要的朋友可以参考下
Java多线程 volatile关键字详解
08-25
Java多线程volatile关键字详解 Java多线程volatile关键字详解主要介绍了Java多线程volatile关键字的应用和原理。volatile是一种轻量同步机制，可以确保变量的可见性和顺序性，但不保证原子性。 volatile关键字的...
java多线程编程之慎重使用volatile关键字
09-04
在Java多线程编程中，volatile关键字扮演着重要的角色，它确保了被声明为volatile的变量在多个线程之间的可见性。然而，尽管volatile能够提供一定程度的线程安全，但并不能保证所有操作都是原子性的。这正是为什么在...
Java多线程并发编程 Volatile关键字
08-30
volatile 关键字是一个神秘的关键字，也许在 J2EE 上的 JAVA 程序员会了解多一点，但在 Android 上的 JAVA 程序员大多不了解这个关键字。只要稍了解不当就好容易导致一些并发上的错误发生，例如好多人把 volatile ...
学习Java多线程之volatile域
09-02
Java多线程中的volatile关键字是Java提供的一个较弱的同步机制，用于解决多线程环境下的数据一致性问题。volatile确保了变量在多个线程之间的可见性，并限制了指令重排序，但并不保证原子性。 首先，理解Java内存...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 782
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
日常工作记录目录
与海
06-21 149
EasyExcel实现二维码下载与展示
Day43
m0_67496588的博客
06-20 1047
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 250
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
多线程访问volatile关键字修饰的资源有什么问题
03-01
多线程访问volatile关键字修饰的资源可能存在可见性问题和原子性问题。因为volatile关键字可以保证被修饰的变量对所有线程的可见性，但是它不能保证对变量的操作具有原子性，也就是说，多个线程同时访问volatile变量...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值