volatile 详解

目录

有什么用？

真的可以保证可见性吗？

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时，内存变化

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

• 有volatile时，内存变化

 

当我们把变量使用 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、分布式锁。。。