一句话说一下volatile

原文：一句话说一下volatile

各位看官，这是个人开场白：volatile并不能保证变量是线程安全的，只能保证线程可以获的取变量最新值。

为何你们老是说 volatile 是轻量级的 synchronized ？轻量级由于它拥有较少的编码和运行开销，也不会形成阻塞，但代价是并不拥有synchronized的所有能力。

名词解释

• 共享变量

若是一个变量在多个线程的工做内存中存在副本，那么这个变量叫作共享变量。

• 可见性

若是一个线程对共享变量的修改，能及时的被其余线程看到，叫作共享变量的可见性。

• 原子性

不可中断的一个或一系列操做。

Java内存模型

咱们先来看看一张图

1. Java内存模型规定了全部变量都存储在主内存，每一个线程还有本身的工做内存，线程的工做内存保存了被该线程使用到的变量的主内存的副本拷贝。

2. 线程对变量的全部读写操做都必须在工做内存中进行，而不是直接读写主内存的变量，不一样线程间也不能相互访问对方的工做内存。

3. 当线程对本身工做内存中的变量操做后，以后会刷新到主内存中，而后其余线程再次读取主内存中的变量才能获取到最新值。

因此这样就形成了一些线程读取的变量不是最新的！那么volatile是怎么解决这个问题的呢？

加入volatile关键字修饰变量后，线程对变量的操做能立马反馈的主内存中，其余线程嗅探到变化，使工做内存变量无效，使用时再次从主存中读取，这样对于其余线程读取的都是最新的值。

举例

可见性

public class Test {

    public boolean flag = false;

    public void waiting() {
        System.out.println("等待flag改变……");
        while (!flag) {
        }
        System.out.println("flag改变完毕……" + flag);
    }
    
    public void change() {
        System.out.println("改变flag");
        flag = true;
    }

    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(() -> test.waiting()).start();
        Thread.sleep(3000L);
        new Thread(() -> test.change()).start();
    }
}
复制代码

执行上面代码，你会发现第一个线程一直处于等待中, 这就符合了上面内存模型的解释了。

而后把变量flag加上关键字volatile，再次运行，你会发现改变flag后，线程就马上运行结束了。

线程不安全状况

public class Test {

    public volatile int count = 0;

    public void change() {
        for (int i = 0; i < 100000; i++) {
            count++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        new Thread(() -> test.change()).start();
        new Thread(() -> test.change()).start();
        new Thread(() -> test.change()).start();
        Thread.sleep(2000L);
        System.out.println(test.count);
    }
}
复制代码

上面代码中变量count加上了volatile关键字，咱们指望三个线程执行后，得出count的值为30万。但实际得出的却远远不足30万。

由于volatile对变量自己的单次读写具备原子性，但count++并非原子操做，它实际上有三步（读取-修改-写入），当多个线程同时进入这三步中，就会出现问题。

可是它也有线程安全的场景，接下来聊聊。

使用条件

volatile 不能代替 synchronized , 但在有限的条件下能够用于线程安全，必须同时知足下面两条件：

1. 对变量的写不能依赖于当前变量的值。（反例：count = count + 1）
2. 当前 volatile 变量不包含在其余变量的不变式中。（反例：volatile1 < var2恒成立)

大多数编程场景都会与这两个条件之一冲突，这也就造就了 volatile 的使用不像 synchronized 那么广泛。

平时使用的场景

状态标记量

这个咱们已经在可见性中写出了。这类有个共性就是：状态标记量不依赖于程序内其余状态，一般只有一种状态转换。

双重检测

class Singleton{
    
    private volatile static Singleton instance = null;
     
    private Singleton() {
         
    }
     
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}
复制代码

这类结合了 synchronized 实现了 volatile 变量的惟一赋值，当赋值成功后其余线程在获取锁以前即可当即知道变量的变化。

往期文章一览

千万不要这样使用 Arrays.asList !

八张图带你认识Java

Java开发必备手册

关注微信公众号 「码上实战」 回复 ：面试视频 和 架构师 送你很是不错的资料！