使用volatile关键字，解决内存可见性的问题

使用volatile关键字，解决内存可见性的问题

什么是内存可见性？：我和你在一家公司上班，是领座的同事，到了晚上了需要开灯才能继续进行工作，这个时候我将灯打开了，按照通常的情况下，你也能马上发现灯亮了。也就是说当某个线程正在使用对象状态，而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

什么是可见性错误？：接着拿我开灯的事情来说，就是当我把灯打开了，你的世界里还是黑的，你并不知道开灯了，这是不符合客观规律的。所以可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。

解决可见性错误的方法：

1. 通过同步锁来保证大家都能看到灯目前最新的状况；
2. 使用轻量级的关键字：volatile。

1. 模拟可见性错误

步骤：

1. 我们需要创建2个线程（main线程–负责读，td线程–负责写）；
2. 在线程td内改变标志的对象；
3. 线程main负责检查标志对象是否被改变了。

模拟代码：

package leo.volatileTest;

public class VolatileTest {

    public static void main(String[] args) {
        // 创建td线程
        ThreadDemo td = new ThreadDemo();
        Thread thread = new Thread(td);
        thread.start();

        // main线程负责检查flag是否被变为了true
        while (true){
            if (td.isFlag()){
                // 如果完成了工作，那么就全部停止
                System.out.println("Thread td finished its work.");
                break;
            }
        }
    }

}

// 实现runnable接口
class ThreadDemo implements Runnable{

    // 内置一个标志变量
    private boolean flag = false;

    // 工作任务是将自己线程内部的标志变量变为true
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        System.out.println("Changed flag from false to " + isFlag() + ".");
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

执行结果：

简述一下为啥会出现这种情况：每一个线程都有自己的缓存，td线程修改了flag的状态时，首先是修改td线程的缓存中flag的数据，然后再提交到主存中去，将主存中的flag修改，但是由于我们main线程执行的是while(true)，这个死循环会调用系统很底层的代码，导致main线程一直查询的是main线程的缓存中flag的属性(默认flag为false)、而没办法去查主存中已经被修改了的最新的flag数据。就相当于，main线程还活在它自己的世界中呢，其实外面的真实世界已经变天了。

2. 利用同步锁解决可见性错误

我们加上synchronized关键字，可以让我们的main方法在读的时候每次都会从主存内读数据，但是显而易见的是，会带来巨大的消耗，非常不建议。

同步锁解决可见性错误代码：

package leo.volatileTest;

public class VolatileTest {

    public static void main(String[] args) {
        // 创建td线程
        ThreadDemo td = new ThreadDemo();
        Thread thread = new Thread(td);
        thread.start();

        // main线程负责检查flag是否被变为了true
        while (true){
            synchronized (td){
                if (td.isFlag()){
                    // 如果完成了工作，那么就全部停止
                    System.out.println("Thread td finished its work.");
                    break;
                }
            }
        }
    }

}

// 实现runnable接口
class ThreadDemo implements Runnable{

    // 内置一个标志变量
    private boolean flag = false;

    // 工作任务是将自己线程内部的标志变量变为true
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        System.out.println("Changed flag from false to " + isFlag() + ".");
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

执行结果：

3. 利用volatile关键完成内存同步刷新

使用volatile修饰标志对象的时候，会使得线程的缓存会实时刷新成主存中的数据，虽然也会增加消耗，但是比起synchronized同步锁还是小的多。

volatile解决可见性错误代码：

package leo.volatileTest;

public class VolatileTest {

    public static void main(String[] args) {
        // 创建td线程
        ThreadDemo td = new ThreadDemo();
        Thread thread = new Thread(td);
        thread.start();

        // main线程负责检查flag是否被变为了true
        while (true){
                if (td.isFlag()){
                    // 如果完成了工作，那么就全部停止
                    System.out.println("Thread td finished its work.");
                    break;
                }
        }
    }

}

// 实现runnable接口
class ThreadDemo implements Runnable{

    // 内置一个标志变量，使用volatile修饰
    private volatile boolean flag = false;

    // 工作任务是将自己线程内部的标志变量变为true
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
        System.out.println("Changed flag from false to " + isFlag() + ".");
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

执行结果：

4. 总结

1. volatile 是一种轻量级的同步策略；
2. volatile 不具备互斥性；
3. volatile 不能保证变量的原子性。