volatile的作用 解决多线程操作同一个数据的不可见性

1.我们要弄清楚的问题？

• 什么是不可见性
• java中的JMM机制是什么
• volatile关键字是什么？它有什莫用
• volatile和synchronized的区别是什么

首先引入一个问题：我们看下面这段代码

package com.Thread.Volatile;

public class VolatileThread extends Thread {
    private boolean flag = false;

    public boolean isFlag() {
        return flag;
    }

    @Override
    public void run() {
        try {
            sleep(1000);
            this.flag = true;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.Thread.Volatile;

public class VolatileThreadDemo {
    public static void main(String[] args) {
        VolatileThread volatileThread = new VolatileThread();
        volatileThread.start();
        while(true){
            if(volatileThread.isFlag()){
                System.out.println("flag的已经修改");
            }
        }
    }
}

子线程已经将flag的值改了，但是主线程没有读到

发现一开始flag的初始值赋给的是false，我们通过volatileThread线程对flag的值修改为true，但我们发现当主线程的的循环语句并未执行，因为主线程还是读到的是false

也就是说 当一个线程去更改数据的时候 有可能会发生 主线程读不到更改后的数据，这就是数据的不可见性。

想要了解，必须要明白java的内存模型

JMM (Java Memory Model Java内存模型

Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节，所有的共享变量都存储于主内存。这里所说的变量指的是实例变量和类变量。不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。线程对变量的所有的操作(读，取)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问，对方工作内存中的变量，线程间变量的值的传递需要通过主内存完成。

按照JMM模型，所有的成员变量和静态变量都存在于主内存中，主内存中的变量可以被多个线程共享， 每个线程都存在一个专属于自己的工作内存，工作内存一开始存储的是成员变量的副本，所以线程很多时候都是直接访问自己工作内存中的该变量，其他线程对主内存变量值的修改将不可见

分析程序的运行步骤：

1. VolatileThread线程从主内存读取到数据放入其对应的工作内存
2. 将flag的值更改为true，但是这个时候flag的值还没有写会主内存
3. 此时main方法读取到了flag的值为false
4. 当VolatileThread线程将flag的值写回去后，但是main函数里面的while(true)调用的是系统比较底层的代码，速度快，快到没有时间再去读取主存中的值，所以while(true)读取到的值一直是false。(如果有一个时刻main线程从主内存中读取到了主内存中flag的最新值，那么if语句就可以执行，main线程何时从主内存中读取最新的值，我们无法控制)

问题的处理：

1. 加锁

某一个线程进入synchronized代码块前后，执行过程入如下：

// 2.定义一个死循环
while(true){
    // 这里读取到了flag值一直是false,虽然线程已经把它的值改成了true。
    synchronized (volatileThread){
        if(volatileThread.isFlag()){
            System.out.println("执行了~~~~~~");
        }
    }
}

a.线程获得锁

b.清空工作内存

c.从主内存拷贝共享变量最新的值到工作内存成为副本

d.执行代码

e.将修改后的副本的值刷新回主内存中

f.线程释放锁

2. 使用volatile关键字

private volatile   boolean flag = false;

看下面的图来看看程序是怎么运行的

1. VolatileThread线程从主内存读取到数据放入其对应的工作内存

2. 将flag的值更改为true，但是这个时候flag的值还没有写会主内存

3. 此时main方法main方法读取到了flag的值为false

4. 当VolatileThread线程将flag的值写回去后，失效其他线程对此变量副本

5. 再次对flag进行操作的时候线程会从主内存读取最新的值，放入到工作内存中

   总结： volatile保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改写回主内存时，另外一个线程立即看到最新的值。

volatile与synchronized的区别

• volatile只能修饰实例变量和类变量，而synchronized可以修饰方法，以及代码块。
• volatile保证数据的可见性，但是不保证原子性(多线程进行写操作，不保证线程安全);而synchronized是一种排他（互斥）的机制

运行结果：

通过volatile或synchronized加锁 就会是main线程重新读取新的flag的值，然后执行了