架构系列——面试必问：volatile的可见性、防止指令重排序以及不能保证原子性的解决方式

public class RunThread extends Thread {
	private boolean isRunning = true;
	private void setRunning(boolean isRunning){
		this.isRunning = isRunning;
	}
	
	public void run () {
		System.out.println("进入run方法");
		while(isRunning == true){
			//...
		}
		System.out.println("线程停止");
	}
	
	public static void main(String[] args) {
		RunThread rt = new RunThread();
		rt.start();
		try {
			Thread.sleep(3000);
			rt.setRunning(false);
			System.out.println("isRunning的值已经被设置成false");
			Thread.sleep(1000);
			System.out.println(rt.isRunning);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

二、volatile能防止指令重排

如下列代码所示，这是单例模式的双检锁写法

public class SingletonTest {
    private volatile static SingletonTest instance = null;
    private SingletonTest() { }
    public static SingletonTest getInstance() {
        if(instance == null) {
            synchronized (SingletonTest.class){
                if(instance == null) {
                    instance = new SingletonTest();  //非原子操作
                }
            }
        }
        return instance;
    }
}

我们看到instance用了volatile修饰，由于 instance = new SingletonTest();可分解为：

1.memory =allocate(); //分配对象的内存空间
2.ctorInstance(memory); //初始化对象
3.instance =memory; //设置instance指向刚分配的内存地址

操作2依赖1，但是操作3不依赖2，所以有可能出现1,3,2的顺序，当出现这种顺序的时候，虽然instance不为空，但是对象也有可能没有正确初始化，会出错。

而使用volatile修饰instance之后，不会出现乱序的行为！

三、volatile不保证原子性以及解决方式

1.什么是原子性？

下列语句中，哪些是原子性操作？

x = 10;         //语句1
y = x;          //语句2
x++;            //语句3
x = x + 1;      //语句4

语句1 是直接将数值 10 赋值给 x，也就是说线程执行这个语句的会直接将数值 10 写入到工作内存中；

语句2 实际上包含两个操作，它先要去读取 x 的值，再将 x 的值写入工作内存。虽然，读取 x 的值以及将 x 的值写入工作内存这两个操作都是原子性操作，但是合起来就不是原子性操作了；

同样的，x++ 和 x = x+1 包括3个操作：读取 x 的值，进行加 1 操作，写入新的值。

只有语句1 的操作具备原子性。也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作！

2.举例

如下列代码所示，使用volatile修饰的变量count，利用10个线程分别对count进行++操作，而根据上面的表述，++操作不是原子操作！每个线程加1000个数，打印的结果中一定有一个是10000才是对的，但是实际上并不是这样！因为volatile不保证原子性！

public class VolatileNoAtomic extends Thread{
	private static volatile int count;
//	private static AtomicInteger count = new AtomicInteger(0);
	private static void addCount(){
		for (int i = 0; i < 1000; i++) {
			count ++;
//			count.incrementAndGet();
		}
		System.out.println(count);
	}
	public void run(){
		addCount();
	}
	
	public static void main(String[] args) {
		VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = new VolatileNoAtomic();
		}
		
		for (int i = 0; i < arr.length; i++) {
			arr[i].start();
		}
	}
}