volatile的作用和基本使用

一、为什么改了值线程不可见？

上一节讲到了怎样创建一个线程，于是写出了一个多线程代码

public class HelloVolatile {
    boolean flag = true;
    void circle() {
        System.out.println("start");
        while(flag) {
        }
        System.out.println("end");
    }

    public static void main(String[] args) {
        HelloVolatile helloVolatile = new HelloVolatile();
        new Thread(helloVolatile::circle, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        helloVolatile.flag = false;
    }
}

运行结果如下：

代码通过一个flag表示来控制循环是否停止，按我们理解主线程flag变为true之后，应该循环停止，会打印出end出来，可是事实没有打印？为什么？

二、线程可见性

通过查相关资料得知，线程为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存后再进行操作，但操作完不知道何时会写到内存。 所以需要一个新的技术实现线程可见性，随之引入了volatile，通过volatile修饰后的变量。可以理解成在变量上加了一个标识。通过这个标识我们可以实现：

1. 保证修改的值会立即被更新到主存；
2. 一个处理器的缓存回写到内存会导致其他处理器的缓存失效；
3. 当处理器发现本地缓存失效后，就会从内存中重读该变量数据，即可以获取当前最新值；

代码修改后

public class HelloVolatile {
    volatile boolean flag = true;
    void circle() {
        System.out.println("start");
        while(flag) {
        }
        System.out.println("end");
    }

    public static void main(String[] args) {
        HelloVolatile helloVolatile = new HelloVolatile();
        new Thread(helloVolatile::circle, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        helloVolatile.flag = false;
    }
}

运行结果:

三、禁止指令重排序

查阅了有关volatile相关信息，还有个作用：禁止指令重排序。

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

instant = new LazySingleton()这个操作编译器编译后在指令分成三步：

1. 申请内存
2. 给成员变量初始化
3. 把这块内存的内容赋值给instance

指令重排序和cpu有关，cpu为了加快运行速度，1、2、3三个步骤执行顺序有可能会重叠，并不一定步骤1执行完了，再执行步骤2，步骤2执行完了，再执行步骤3。
如图：

所以在极端情况下，步骤3将内存已经赋值给了instance，可是步骤2还没有完成。恰好另外一个线程进来发现instance==null且synchronized锁也释放了，则又 new LazySingleton()一次，导致的问题。
如果加上volitale后，则步骤1执行完了，再执行步骤2，步骤2执行完了，再执行步骤3来禁止指令重排序。但是在很极端的情况下才会发生，本机很难复测出这种情况，只需要记住这个概念，在高并发下记住有这个问题存在，记得使用volitale即可。

四、volitale无法保证原子性，需要借助synchronize保证原子性

学习了synchronize和volitale之后，忽然会觉得synchronize某种情况下岂不是无效，直接用volitale即可。如下：

public class VolatileNotHaveSync {
	volatile int count = 0;

	 void m() {
		for (int i = 0; i < 10000; i++)
			count++;
	}

	public static void main(String[] args) {
		VolatileNotHaveSync t = new VolatileNotHaveSync();

		List<Thread> threads = new ArrayList<Thread>();
		for (int i = 0; i < 10; i++) {
			threads.add(new Thread(t::m, "thread-" + i));
		}
		threads.forEach((o) -> o.start());
		threads.forEach((o) -> {
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		System.out.println(t.count);

	}

}

执行结果：

没有得到预期的结果100000，为什么呢？
其实很简单，volitale只能保证线程间的可见性，但是无法保证原子性，多个线程同时读取这个值时，进行count++，则会出现错误结果。
修改代码如下：

public class VolatileNotHaveSync {
	volatile int count = 0;

	 synchronized void m() {
		for (int i = 0; i < 10000; i++)
			count++;
	}

	public static void main(String[] args) {
		VolatileNotHaveSync t = new VolatileNotHaveSync();

		List<Thread> threads = new ArrayList<Thread>();
		for (int i = 0; i < 10; i++) {
			threads.add(new Thread(t::m, "thread-" + i));
		}
		threads.forEach((o) -> o.start());
		threads.forEach((o) -> {
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		System.out.println(t.count);

	}
}

运行结果如下：

结果如预期一致。