[Java]volatile关键字

进步·于辰

已于 2024-06-02 23:51:27 修改

阅读量1.2w

点赞数 1

分类专栏： Java知识点文章标签： volatile 可见性有序性 DCL

于 2023-11-16 01:43:37 首次发布

本文链接：https://blog.csdn.net/m0_69908381/article/details/134430096

版权

Java知识点专栏收录该内容

16 篇文章 2 订阅

订阅专栏

本文详细解读了Java的volatile关键字，介绍了其在并发编程中的作用，包括JMM规范、可见性、原子性和内存屏障。通过实例演示了volatile如何确保线程安全，以及在单例模式中的应用，强调了指令重排的问题及其解决方案。

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

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://blog.csdn.net/m0_69908381/article/details/134430096
出自【进步*于辰的博客】

启发博文：《Java volatile关键字最全总结：原理剖析与实例讲解(简单易懂)》（转发）。

参考笔记二，P73、P74.1；笔记三，P61。

在学习此关键字之前，我们先了解一下JMM规范和并发编程中的三个概念。

1、JMM规范

JMM（Java module memory，Java内存模型）是一个抽象概念，并不真实存在于内存。它是用于定义程序中各个变量（成员变量、类变量、数组元素等）的一组规范和规则，指定变量的访问方式。

$\color{red}{规定：}$

线程解锁之前必须将共享变量刷新回主内存。
线程加锁之前必须读取主内存中变量的最新值到工作空间。
解锁和加锁必须是同一把锁。

大家可能不解其意，这就需要涉及另一个概念： $\color{green}{线程空间}$ .。

$\color{grey}{什么是线程空间？}$ 程序执行JMM规范的实体是线程，当线程创建时，JMM会为其创建一个私有内存（也称为工作内存、本地内存或栈空间）。JMM规定所有变量都保存在主内存，线程访问变量时需为变量创建一个副本至工作内存进行操作，完成后将变量值返回主内存，且线程通信在主内存进行。

$\color{red}{注意}$ ：JMM作为抽象概念，规定中的“主内存”与“私有内存”等概念同样是抽象概念，并不一定真实对应CPU中的缓存和物理内存。

2、并发编程的三个概念

1：可见性
可见性指线程对变量的修改，其他线程可见，即由volatile修饰的变量，其私有内存失效。（具体说明见下文）

2：原子性
原子性指线程对变量的操作的整个过程不会被阻塞或分割。

原子性表示“拒绝多线程并发操作”，即同一时刻只能有一个线程进行操作。因此，在整个操作过程中不会被线程调度中断。

如：a = 1是原子操作，而a++不是，因为它分为读取、计算和赋值三个步骤。

在Java中，原子操作包括：

基本数据类型的读取与赋值，但限于将值赋给变量，变量间赋值不是原子操作。
引用赋值。
java.util.concurrent.atomic包中所有类的一切操作。

3：有序性
有序性也称为 $\color{green}{“指令重排”}$ ，指程序运行时，编译器基于提高性能需要，以指令间的数据依赖性作为依据对指令进行重新排列。执行顺序：编译器重排 → 指令并行重排 → 内存系统重排。

单线程环境下，无论指令如何重排，结果都不变，但多线程时可能会出现问题。

3、volatile

3.1 介绍

volatile是一种轻量级的同步机制，与synchronized有一些通性，但synchronized属于重量级（“级”是指对变量访问的限制程度）。

volatile遵循JMM规范实现了可见性和有序性，但不保证原子性。因此，限制线程在访问由volatile修饰的变量时，从主内存获取数据，而不是从工作内存。在数据操作完成后再刷新回主内存，故在保证原子性的情况下，线程安全。

$\color{grey}{如何保证原子性？}$
两种方法：

程序中不存在多线程对变量进行非原子性操作。
见下文。

3.2 volatile原理

在JVM底层，volatile是采用“ $\color{blue}{内存屏障}$ ”来实现的。在所生成的汇编代码中可见，在volatile前多出了一条Lock前缀指令，这相当于内存屏障（也称为“内存栅栏”），其提供三项功能：

屏蔽指令重排。
强制私有内存的修改立即写入主内存。
执行写操作时，致使CPU中其他线程的私有内存无效。

这就是为何volatile可实现可见性和有序性，但不保证原子性的原因。

3.3 如何保证原子性？

大家先看个示例。

static volatile int x = 0;
private static void add() {
    x++;
}

public static void main(String[] args) throws Exception {
    Thread t1 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    Thread t2 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(x);
}

请问最后的x是200000吗？绝大概率不是，因为volatile不能保证原子性，而x++又不是原子操作，可谓必然会出现并发问题。

那么，volatile如何保证原子性？从上文【volatile原理】可得，volatile本身是无法保证原子性的，故需要采取其他方案。如下：

1：synchronized。

static int x = 0;
private synchronized static void add() {
    x++;
}

public static void main(String[] args) throws Exception {
    Thread t1 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    Thread t2 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(x);
}

2：Lock。

static int x = 0;
// Lock的原理类似synchronized
static Lock lock = new ReentrantLock();

private static void add() {
    lock.lock();// 可视为内存屏障”，当然实际不是
    x++;
    lock.unlock();
}

public static void main(String[] args) throws Exception {
    Thread t1 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    Thread t2 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(x);
}

3：AtomicInteger。

// 原子操作类是通过CAS循环的方式来保证原子性
static AtomicInteger x = new AtomicInteger();

private static void add() {
    x.getAndIncrement();
}

public static void main(String[] args) throws Exception {
    Thread t1 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    Thread t2 = new Thread(() -> {
        int i = 100000;
        while (i-- > 0) {
            add();
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(x);
}

4、volatile的一个经典运用

从文章《[Java]单例模式》中截取这段代码：

public static Singleton newInstance() {
    if (instance == null) {--------------------A
        synchronized (Singleton.class) {-------B
            if (instance == null) {------------C
                instance = new Singleton();----D
            }
        }
    }
    return instance;---------------------------E
}