JAVA多线程之volatile关键字

最新推荐文章于 2024-10-11 17:32:18 发布
最新推荐文章于 2024-10-11 17:32:18 发布
阅读量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
    }
}
Java线程：volatile关键字
05-17
主要讲述java线程volatile关键字
java线程volatile_Java：多线程中的volatile
weixin_42665725的博客
02-17 207
一、为什么使用volatile首先，通过一段简单的代码来理解为什么要使用volatile：1 public class RunThread extendsThread{2 private boolean isRunning = true;3 public booleanisRunning(){4 returnisRunning;5 }67 public vo...
【Java并发编程】关键字volatile详解
最新发布
叉烧钵钵鸡的博客
10-11 1119
详细解析了 Java 中 volatile 关键字的原理和应用，探讨了其在多线程环境下如何保证变量可见性和有序性，以及无法保证原子性的原因。
java线程volatile_Java多线程之volatile
weixin_34036667的博客
02-17 224
Java多线程是一个庞大的知识体系，这里对其中的volatile进行一个总结，理清他的来龙去脉。CPU缓存要搞懂volatile，首先得了解CPU在运行过程中的存储是如何处理的，其结构如图CPU会把一些经常使用的数据缓存在cache中，避免每次都去访问较慢的memory。在单线程环境下，如果一个变量的修改都在cache中，自然不会有什么问题，可是在多线程环境中就可能是下面这个图的示意图(单核另当别...
Java多线程之volatile
qq_42878176的博客
12-12 409
在Java多线程内存模型中，线程对某个主存中的变量进行修改时，对另一个也用到这个变量的线程来说是不可见的。但需要注意的是，volatile只能保证用到volatile变量代码前后的有序性，不保证再往后的代码（比如println之后的）。下面的代码，我们预想的结果应该是4000，但执行结果是无法预测的。对一个 volatile 变量的写操作 Happens-Before 于对这个 volatile 变量的读操作。解决办法：1. 加锁；交换执行顺序，是不会影响线程1的执行结果的，线程2也一样。
java多线程—volatile
qq_44371305的博客
04-29 861
volatile和 synchronized 的区别： volatile 提升变量对线程的可见性 ，而非原子性 synchronized同步方法和同步代码块是原子性的 volatile是轻量级，只能修饰变量。synchronized是重量级，作用于一段代码或者方法 可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。 1.可见性验证 运行以下代码， public class Demo11 { static boolean fla
Java多线程之volatile关键字及内存屏障实例解析
08-25
总结来说，volatile关键字在Java多线程编程中起着关键作用，它提供了轻量级的同步机制，通过内存屏障保证了变量的可见性和有序性，避免了多线程环境下数据不一致的问题。但需要注意的是，volatile不能保证操作的原子...
Java多线程 volatile关键字详解
08-25
Java多线程volatile关键字详解 Java多线程volatile关键字详解主要介绍了Java多线程volatile关键字的应用和原理。volatile是一种轻量同步机制，可以确保变量的可见性和顺序性，但不保证原子性。 volatile关键字的...
【Java多线程学习4】volatile关键字及其作用
weixin_43950588的博客
08-01 457
volatile关键字及其作用
Java并发教程之volatile关键字详解
08-25
在Java中，volatile关键字是解决多线程问题的重要工具。本文将会详细介绍volatile关键字的原理、使用场景和注意事项。 知识点1：理解多线程问题 在多线程环境下，线程安全问题是最重要的问题。Java内存模型（JMM）...
Java多线程：volatile关键字
流楚丶格念的博客
07-17 1317
当A线程修改了共享数据时，B线程没有及时获取到最新的值，如果还在使用原先的值，就会出现问题堆内存是唯一的，每一个线程都有自己的线程栈。每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。在线程中，每一次使用是从变量的副本中获取的。......
java volatile 基本类型_谈谈Java中的volatile
weixin_33900596的博客
02-16 254
内存可见性volatile是Java提供的一种轻量级的同步机制，在并发编程中，它也扮演着比较重要的角色。同synchronized相比(synchronized通常称为重量级锁)，volatile更轻量级，相比使用synchronized所带来的庞大开销，倘若能恰当的合理的使用volatile，自然是美事一桩。为了能比较清晰彻底的理解volatile，我们一步一步来分析。首先来看看如下代码publ...
java线程volatile_Java多线程之volatile详解
weixin_39875028的博客
02-12 177
本文目录从多线程交替打印A和B开始Java 内存模型中的可见性、原子性和有序性Volatile原理volatile的特性volatile happens-before规则volatile 内存语义volatile 内存语义的实现CPU对于Volatile的支持缓存一致性协议工作内存(本地内存)并不存在总结参考资料从多线程交替打印A和B开始面试中经常会有一道多线程交替打印A和B的问题，可以通过使用L...
java 线程volatile_Java 多线程经典面试题volatile
weixin_42212792的博客
03-05 149
问题当多个线程并发同时进行set、get时，其它线程能否感知到flag的变化public class ThreadSafeCache {boolean flag = true;//默认设置truepublic boolean isFlag() {return flag;}public synchronized ThreadSafeCache setFlag(boolean flag) {this....
java线程volatile_详解Java线程编程中的volatile关键字的作用
weixin_29531989的博客
02-12 207
1.volatile关键字的两层语义一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后，那么就具备了两层语义：1)保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。2)禁止进行指令重排序。先看一段代码，假如线程1先执行，线程2后执行：//线程1boolean stop = false;while(!stop){do...
javase - 多线程之volatile
The Secret
01-03 191
  目录 特性（一）：实时可见性 特性（二）：禁止指令重排序  volatile ：英文的字面意思是易变的、不稳定的。 特性（一）：实时可见性 （什么意思？一个线程对属性进行写操作，通知其他线程。告诉他们，这个属性已经发生了改变。） 通过一个demo讲解下。如下： package com.test.testDemo3; import com.test.testThread....
Java 多线程volatile关键字
抛弃幻想，准备斗争
03-21 220
通过使用volatile关键字，强制的从公共内存中读取变量的值。 使用volatile关键字增加了实例变量在多个线程之间的可见性。 但是volatile关键字不支持原子性。 关键字synchronized和volatile进行比较： 1.关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好， 并且volatile只能修饰于变量，而synch...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值