Java多线程之volatile详解

volatile作用

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最新的值。即每次读取volaile修饰的变量，都会强制性的从公共堆栈中进行取值，而不是从线程私有堆栈中获取。volatile是非线程安全的，最致命的缺点是不支持原子性。

针对多线程使用的变量如果不是volatile或者final修饰的，很有可能产生不可预知的结果（另一个线程修改了这个值，但是之后在某线程看到的是修改之前的值）。其实道理上讲同一实例的同一属性本身只有一个副本，但是多线程是会缓存值的（分为主存和线程内存），本质上，volatile就是不去线程内存取，而直接从主存取值。在线程安全的情况下加volatile会牺牲性能。

一个例子

先来看一段代码：

public class Main {
    public static int count = 0;

    public static void inc() {
        //这里延迟1毫秒，使得结果明显
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
        }

        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        //同时启动1000个线程，去进行i++计算，看看实际结果
        for (int i = 0; i < 1000; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Main.inc();
                }
            }).start();
        }

        //这里每次运行的值都有可能不同,可能为1000
        System.out.println("运行结果:Counter.count=" + Main.count);
    }
}

运行结果：Counter.count=938

实际运行结果每次可能不一样。可以看出，在多线程情况下，得到的结果并不是我们想要的1000。很多人认为在count前面加volatile，就可以确保得到我们预期值，试试看：

public static volatile int count = 0;

运行结果：Counter.count=459
发现结果还是一样，并不是我们预期的。

剖析

多线程的内存模型：main memory（主存）、working memory（线程内存），在处理数据时，线程会把值从主存load到本地栈，建立一个变量副本，在完成操作后再save回去。

这一些操作并不是原子性，也就是 在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样。

对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的

假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值。在线程1对count进行修改之后，会write到主内存中，主内存中的count变量就会变为6。线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6

多线程在对volatile变量修改之后，还是会存在并发的情况。用volatile修饰的变量，在线程每次调用的时候，都会从主存取，操作完以后都会同步保存到主存！！！

再看一个例子

public class Main {
    class VisibilityTest extends Thread {
        private boolean stop;
        public void run() {
            int i = 0;
            while(!stop) {
                i++;
            }
            System.out.println("finish loop;i=" + i);
        }

        public void stoplt() {
            stop = true;
        }

        public boolean getStop() {
            return stop;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Main main = new Main();
        VisibilityTest v = main.new VisibilityTest();
        v.start();

        Thread.sleep(1000);
        v.stoplt();
        Thread.sleep(2000);
        System.out.println("finish main");
        System.out.println(v.getStop());
    }
}

运行以上代码，会发现其实结束不了线程的，程序会一直在进行i++，这和我们预想的不一样。因为，stop变量在线程启动的时候只会进行一次while(!stop)判断，当main所处的线程对这个变量进行修改的时候，它是视而不见的。

修正如下：变量stop添加一个属性volatile

private volatile boolean stop;

这样线程每次读取到这个变量的时候，就会去主存获取到最新的值

使用场景

volatile的使用场景如下：

• 只有一个线程写，多个线程读的时候

• volatile变量的变化很固定