关于对Java中volatile关键字的理解与简述

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

启发之作：Java volatile关键字最全总结：原理剖析与实例讲解(简单易懂)（转发）。
参考笔记二，P73、P74.1。

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

1、关于JMM规范

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

$规定：$

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

大家可能不解其意，这就需要涉及另一个概念：$线程空间$.。
$什么是线程空间？$
程序执行JMM规范的实体是线程，当线程创建时，JMM会为其创建一个私有内存（也称为$工作内存、本地内存或栈空间$）。JMM规定所有变量都保存在主内存，线程访问变量时需为变量创建一个副本至工作内存进行操作，完成后将变量值返回主内存，且线程通信在主内存进行。

2、关于volatile

并发编程的三个概念：

1. $可见性：$指线程对变量的修改，其他线程可见；
2. $原子性：$指线程对变量的操作的整个过程不会被阻塞或分割；
3. $有序性：$也称为$“指令重排”$，指程序运行时，编译器基于提高性能需要，以指令间的数据依赖性作为依据对指令进行重新排列。执行顺序：编译器重排 → 指令并行重排 → 内存系统重排。

volatile$是什么？$
volatile是一种轻量级的同步机制，而synchronized是一种重量级的同步机制（“级”是指对变量访问的限制程度）。volatile遵循JMM规范实现了可见性和有序性，但不保证原子性。因此，限制线程在访问由volatile修饰的变量时，从主内存获取数据，而不是从工作内存，在数据操作完成后再刷新回主内存，故在保证原子性的情况下，可实现线程安全。

注：如何保证原子性？如程序中不存在多线程对变量进行非原子性操作，举个例：a++是原子操作，而a+=1不是。

volatile$的一个经典应用：$

关于单例模式，可查阅博文【关于对Java单例模式的理解与简述】。

从文中可知，$“双重检测机制”$可解决“懒汉式”的线程安全问题。其实，“双重同步锁”也有漏洞。
以那篇博文的示例为例：

instance = new Singleton();
1

实例化分为三步：1、创建实例，分配内存；2、实例初始化；3、令instance指向此实例。其中，2和3都依赖于1，而2与3之间没有依赖关系，故指令重排会将2与3对调（原因可能是实例初始化耗时较长）。因此，当instance指向实例时，实例可能还未初始化，下一个线程就会出现并发问题（暂不清楚原因），用volatile禁止指令重排即可解决。

3、关于volatile的运用

学以致用才是检验学习效果最好的方法。从上文可知，volatile关键字可以解决这两种情形下的线程安全问题。

1. 多线程并发访问变量，线程体中不存在非原子操作的情况；
2. 弥补$双重同步锁$的漏洞。

那我们就一一测试检测一下。

1、情形一：创建10个线程对同一个成员变量并发修改1万次。
示例。

volatile int a;
public static void main(String[] args) throws Exception {
    C c1 = new C();// C 是当前类名
    int i = 10;
    while (i-- > 0) {
        new Thread(() -> {
            int n = 10000;
            while (n-- > 0) {
                c1.a++;
            }
        }).start();
    }
    Thread.sleep(10000);// 主线程停留10s足以保证10个子线程运行完成
    System.out.println(c1.a);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

最后c1.a的输出结果并不是100000（10s足够10个子线程执行完成）。可见，并未解决线程安全问题。

2、情形二：多线程并发调用newInstance()获取单例模式类实例。
实体类。

class SingleTon {
    private static SingleTon instance;
    private SingleTon() {}
    public static SingleTon newInstance() {
        if (instance == null) {
            synchronized (SingleTon.class) {
                if (instance == null) {
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

测试：创建一万个线程并发调用newInstance()，判断获取的实例是否都为单例。

List<SingleTon> list = new Vector<>();
int i = 10000;
while (i-- > 0) {
    new Thread(() -> {
        SingleTon s1 = SingleTon.getInstance();
        if (list.size() > 0 && list.indexOf(s1) == -1)
            System.out.println("违反单例");// 未执行
        list.add(s1);
    }).start();
}
Thread.sleep(1000);
System.out.println(list.size());// 10000
1
2
3
4
5
6
7
8
9
10
11
12

Vector 类线程同步，故list.add(s1)也是线程同步的。
未打印“违反单例”，表示list中存储的所有s1都指向同一个实例，保证了“单例”，说明线程安全。

不过，还证明不了这是volatile的功劳，因为$双重检测机制$本身对线程安全就有很大的保证性。
于是，我把10000改成了100000，好吧。。。还是未打印“违反单例”，看来双重同步锁真的很强大。

4、最后

大家肯定也看出来了，在上面的示例中，我的本意是想创建十万个线程调用newInstance()，通过是否打印“违反单例”来触发$双重同步锁$的漏洞，然后用volatile声明instance来解决线程安全问题，可我失败了。。。
大家也看得出来，我对volatile关键字的理解还不够透彻，毕竟哪有这样测试的。
因此，本文的目的是为了让大家对volatile关键字有一个初步的了解，我继续努力！！

本文完结。