Volatile（一）

案例

一、volatile修饰的变量的可见性

变量isRunning 不用volatile修饰的情况

public class VolatileTest extends Thread{
    private boolean isRunning = true;

    private void setRunning(boolean isRunning){
        this.isRunning = isRunning;
    }
	@Override
    public void run(){
        System.out.println("子线程进入run方法");
        System.out.println("子线程执行中。。。isRunning=" + this.isRunning);
        while (isRunning == true){
            //
        }
        System.out.println("子线程停止");
    }

    /**
     * 当isRunning不用volatile修饰的时候，主线程修改了isRunning的值，volatileTest.start()开启的线程并不知道，该线程不会停止
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        VolatileTest volatileTest = new VolatileTest();
        volatileTest.start();
        Thread.sleep(3000);
        volatileTest.setRunning(false);
        System.out.println("主线程将isRunning的值设置为false");
        Thread.sleep(1000);
        System.out.println("isRunning=" + volatileTest.isRunning);
    }
}

根据java的内存模型，两个线程中使用到的变量都从主内存中获取，拷贝一份放到各自的线程的工作内存中，对于普通的变量，在两个线程之间是互不可见的，所以在主线程将isRunning的值设置为false之后，子线程并不知道，子线程并不会停止。

变量isRunning 用volatile修饰的情况

public class VolatileTest extends Thread{
    private volatile boolean isRunning = true;

    private void setRunning(boolean isRunning){
        this.isRunning = isRunning;
    }
    @Override
    public void run(){
        System.out.println("子线程进入run方法");
        System.out.println("子线程执行中。。。isRunning=" + this.isRunning);
        while (isRunning == true){
            //
        }
        System.out.println("子线程停止");
    }

    /**
     * 当isRunning不用volatile修饰的时候，主线程修改了isRunning的值，volatileTest.start()开启的线程并不知道，该线程不会停止
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        VolatileTest volatileTest = new VolatileTest();
        volatileTest.start();
        Thread.sleep(3000);
        volatileTest.setRunning(false);
        System.out.println("主线程将isRunning的值设置为false");
        Thread.sleep(1000);
        System.out.println("isRunning=" + volatileTest.isRunning);
    }
}

当A线程在自己的工作内存中修改了volatile修饰的变量，会将修改后的新值刷新到主内存中，并通知其他线程从新从主内存中获取该值，保证了变量在不同线程中的可见性

二、volatile修饰的变量的原子性

普通变量

public class VolatileNoAtomic extends Thread{
    private static volatile int count;
    
    private static void addCount(){
        for (int i = 0; i < 1000; i++) {
            count++;
        }
        System.out.println(count);
    }

    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        addCount();
    }

    public static void main(String[] args) {
        VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
        //创建十个线程对象
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }
        //启动十个线程，每个线程对执行count++ 1000次
        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }
}

上面的代码，创建了10个线程，每个线程调用实例对象执行1000次count++操作，每次线程阻塞100ms，正常情况下，由于count具有可见性，在每个线程中执行1000次count++，共10个线程执行，最后count的结果应该是10000。而实际情况却是这样的：

从上面输出结果可以看出count结果不为10000，这是因为当一个线程在从住内存中获取count最新值进行count++的时候，过程为三步：

• 首先从住内存取值赋值给工作内存count
• 执行count++
• 将count新值刷新到主内存

线程1对变量进行自增操作，假如线程1先读取了变量count的原始值10，然后线程1被阻塞了，然后线程2对变量进行自增操作，线程2也去读取变量count的原始值，由于线程1只是对变量count进行读取操作，而没有对变量进行修改操作(写入主内存)，所以不会导致线程2的工作内存中缓存变量count无效，所以线程2会直接去主存读取count的值，发现count的值是10，然后进行加1操作，并把11写入工作内存，最后写入主存，此时线程1再对count进行自加操作，count的值已经不是最新的值，所以这就导致了最后的结果不是10000

原子类变量

使用原子类保证原子性

public class VolatileNoAtomic extends Thread{
    private static AtomicInteger count = new AtomicInteger(0);
    private static void addCount(){
        for (int i = 0; i < 1000; i++) {
            count.incrementAndGet();
        }
        System.out.println(count);
    }
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        addCount();
    }
    public static void main(String[] args) {
        VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
        for (int i = 0; i < 10; i++) {
            arr[i] = new VolatileNoAtomic();
        }
        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }
}

单例模式中volatile的作用

public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
            Singleton.getInstance();
    }
}

这段代码看起来很完美，很可惜，它是有问题。主要在于instance = new Singleton()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

• 给 instance 分配内存
• 调用 Singleton 的构造函数来初始化成员变量
• 将instance对象指向分配的内存空间（执行完这步instance 就为非 null 了）

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，另一个线程执行了getInstance()方法，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错，解决方法就是将 instance 变量声明成 volatile 就可以了。

给instance变量赋值部分代码如下：