volatile关键字 java_解析Java的volatile关键字

众所周知，无限制下多线程操作共享变量是危险的，为了保证线程安全语义，一般的建议是在操作共享变量时加锁，比方说在用synchronized关键字修饰的方法内读写共享变量。

但是synchronized开销较大，有没有更轻量更优雅的解决方案呢？

volatile是轻量级的synchronized，在正确使用的前提下，它可以达到与synchronized一样的线程安全的语义，而且不会带来线程切换的开销。

volatile的作用是什么？

volatile保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。它在某些情况下比synchronized的开销更小。

这句话可能难以理解，我来举个例子。

在我之前写的这篇文章中，第一个给出的naive lock的例子里，flag变量被声明为volatile。

如果flag不是volatile而是普通变量，那会发生什么呢？

想象一个场景：线程A正在占有锁，线程B自旋监听flag变量。现在线程A退出临界区，将flag置为false。但是线程B能立即观察到flag的变化吗？

很不幸，不一定。

因为现代CPU中有多个core，每个core都有各自的高速缓存(cache)，线程A对flag的修改只写在了cache上，需要一段不确定的时间才会被刷新到主存中。而线程B所在的core也会将flag变量缓存在cache中，这样就算主存中的flag变量发生了变化，线程B还是不一定能看到。

所以，如果flag是普通变量，naive lock是不成立的。

而如果将flag设置为volatile类型，JVM就会保证任何对flag变量的写操作会被立即刷新到主存里，同时还会让其他缓存了flag变量的core的对应的cache line失效，强迫其他线程必须从主存中读取最新的值。

这样就实现了共享变量被一个线程修改，其他线程立刻就能读到的语义。

那么volatile关键字的底层原理是什么呢？它是如何让写操作直接被刷新到主存，又是如何让其他core的cache line失效的呢？

如果观察编译出来的机器码，会发现在对volatile变量的写操作之后，会附加一条指令

lock addl $0x0,(%esp);

很容易可以看出，addl $0x0,(%esp) 这句话本身是没有任何作用的，效果与nop这样的空转指令等同，但是前面的lock前缀，有点意思。

查阅Intel的，里面有这样一段话

8.1.4 Effects of a LOCK Operation on Internal Processor Caches

For the Intel486 and Pentium processors, the LOCK# signal is always asserted on the bus during a LOCK operation, even if the area of memory being locked is cached in the processor.

For the P6 and more recent processor families, if the area of memory being locked during a LOCK operation is cached in the processor that is performing the LOCK operation as write-back memory and is completely contained in a cache line, the processor may not assert the LOCK# signal on the bus. Instead, it will modify the memory location internally and allow it’s cache coherency mechanism to ensure that the operation is carried out atomically. This operation is called “cache locking.” The cache coherency mechanism automatically prevents two or more processors that have cached the same area of memory from simultaneously modifying data in that area.

大概意思是说，遇到lock指令，对应的core上的cache line会被强制刷回到主存中。然后由于缓存一致性协议的效果(参见我的这篇博客)，其他core上的对应的cache line也会被强制设置为invalid。

于是volatile的语义就实现了，仅需这一条lock指令。

但是volatile能保证原子性吗？比方说如果我们多线程对一个volatile型的变量做自增操作，这是线程安全的吗？

答曰：并不是。

我们想象有两个线程对volatile类型的变量count做自增操作，count初始值为0，两个线程同时拿到了0，同时自增为1，然后同时写回，这样count的结果还是1，不符合期望。

那么我们应该怎么办呢？

参考AtomInteger，使用UNSAFE提供的CAS操作更新count，在上面的场景中，两个线程同时执行CAS(count, 0, 1)，只有其中一个线程能执行成功，另外一个线程失败重试，读取新的count值，然后执行CAS(count, 1, 2)，这一次执行成功了，那么count的最终值是2。符合期望。

参考资料：