volatile 详解

﹏ヽ暗。殇╰゛Y 2024-03-25 08:31 56阅读 0赞

**目录**

有什么用？

真的可以保证可见性吗？

volatile之前

加上volatile关键字

volatile怎么保证的可见性

问题01、不加volatile也可见吗

代码测试

结果

为什么呢？

问题02、volatile线程安全吗？

代码测试

结果

为什么呢？

总结

--------------------

## 有什么用？ ##

volatile是一个特征修饰符（type specifier）. volatile的作用是**作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值**。 volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。

一句话：**主要用于解决变量在多个线程之间的可见性**

## 真的可以保证可见性吗？ ##

### volatile之前 ###

public class VolatileTest {
    
        public static void main(String[] args) {
            final VT vt = new VT();
    
            Thread Thread01 = new Thread(vt);
            Thread Thread02 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException ignore) {
                    }
                    vt.sign = true;
                    System.out.println("vt.sign = true 通知 while (!sign) 结束！");
                }
            });
    
            Thread01.start();
            Thread02.start();
        }
    
    }
    
    class VT implements Runnable {
    
        public boolean sign = false;
    
        @Override
        public void run() {
            while (!sign) {
            }
            System.out.println(Thread.currentThread().getName()+"我出来啦");
        }
    }

**这段代码**，是两个线程操作一个变量，程序期望当 `sign` 在线程 Thread01 被操作 `vt.sign = true` 时，Thread02 输出 *“我出来啦”*。

但实际上这段代码永远不会输出 *你坏*，而是一直处于死循环。这是为什么呢？接下来我们就一步步讲解和验证。

### 加上volatile关键字 ###

我们把 sign 关键字加上 volatitle 描述，如下：

class VT implements Runnable {
    
        public volatile  boolean sign = false;
    
        @Override
        public void run() {
            while (!sign) {
            }
            System.out.println(Thread.currentThread().getName()+"我出来啦");
        }
    }

**测试结果**

> **vt.sign = true 通知 while (!sign) 结束！  
> Thread-0我出来了**

volatile关键字是Java虚拟机提供的的最轻量级的同步机制，它作为一个修饰符出现，用来修饰变量，但是这里不包括局部变量哦

在添加 volatile 关键字后，程序就符合预期的输出了 *“我出来啦”*。从我们对 volatile 的学习认知可以知道。volatile关键字是 JVM 提供的最轻量级的同步机制，用来修饰变量，用来保证变量对所有线程可见性。

正在修饰后可以让字段在线程见可见，那么这个属性被修改值后，可以及时的在另外的线程中做出相应的反应。

### volatile怎么保证的可见性 ###

*  无volatile时，内存变化

![1fd8b1f4aaa54b84b906dcd1f29b75d7.png][]

首先是当 sign 没有 volatitle 修饰时 `public boolean sign = false;`，线程01对变量进行操作，线程02并不会拿到变化的值。所以程序也就不会输出结果

*  有volatile时，内存变化

![e719fe797901416cb21666c7e22f2bdf.png][]

当我们把变量使用 volatile 修饰时 `public volatile boolean sign = false;`线程01对变量进行操作时，会把变量变化的值强制刷新的到主内存。当线程02获取值时，会把自己的内存里的 sign 值过期掉，之后从主内存中读取。所以添加关键字后程序如预期输出结果。

## 问题01、不加volatile也可见吗 ##

### 代码测试 ###

我们现在再把例子修改下，在 `while (!sign)` 循环体中添加一段执行代码，如下；

class VT implements Runnable {
    
        public boolean sign = false;
    
        @Override
        public void run() {
            while (!sign) {
                System.out.println("我在这疯狂自旋");
            }
            System.out.println(Thread.currentThread().getName()+"我出来了");
        }
    }

### 结果 ###

修改后去掉了 `volatile` 关键字，并在while循环中添加一段代码。现在的运行结果是：

。。。。。。
    我在这疯狂自旋
    我在这疯狂自旋
    我在这疯狂自旋
    我在这疯狂自旋
    vt.sign = true 通知 while (!sign) 结束！
    Thread-0我出来了

**咋样**，又可见了吧！

### 为什么呢？ ###

这是因为在没 volatile 修饰时，jvm也会尽量保证可见性。

## 问题02、volatile线程安全吗？ ##

### 代码测试 ###

public class VolatileTest {
    
        volatile int number = 0;
    
        public void addPlusPlus() {
            number++;
        }
    
        public static void main(String[] args) {
            VolatileTest volatileAtomDemo = new VolatileTest();
            for (int j = 0; j < 30; j++) {
                new Thread(() -> {
                    for (int i = 0; i < 1000; i++) {
                        volatileAtomDemo.addPlusPlus();
                    }
                }, String.valueOf(j)).start();
            }// 后台默认两个线程：一个是main线程，一个是gc线程
            while (Thread.activeCount() > 2) {
                Thread.yield();
            }
            // 如果volatile保证原子性的话，最终的结果应该是30000 // 但是每次程序执行结果都不等于30000
            System.out.println(Thread.currentThread().getName() +
                    " final number result = " + volatileAtomDemo.number);
        }
    
    }

### 结果 ###

> 29881、29302、29530、29729、29619、28417、29408、28958、29810。。。。。。

如果volatile保证原子性的话，最终的结果应该是30000 // 但是每次程序执行结果都不等于30000

### 为什么呢？ ###

他能保证可见性和有序性，但是不能保证原子性，因为java里的运算是非原子的，比如jvm处理一个变量需要先load到线程栈中，然后在线程栈中改变值，最后在线程退出的时候，才会改变java堆的值，这些操作不会保证原子性。

所以想要线程安全还得加上锁，如synchronized、Lock、分布式锁。。。

## 总结 ##

*  volatile会控制被修饰的变量在内存操作上主动把值刷新到主内存，JMM 会把该线程对应的CPU内存设置过期，从主内存中读取最新值。
 *  volatile有三个重要的特性，可见性，有序性，线程不安全性
 *  volatile 并不能解决原子性，如果需要解决原子性问题，需要使用 synchronized、Lock、分布式锁。。。

[1fd8b1f4aaa54b84b906dcd1f29b75d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3bbe5d2ee4294e3d96965139bc3b0667.png
[e719fe797901416cb21666c7e22f2bdf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3b0d8fcf16a74a61b595eb624e80bcd4.png