一、volatile简介

Java语言规范第三版中对volatile的定义如下：

java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁更加方便。如果一个字段被声明成volatile，java线程内存模型确保所有线程看到这个变量的值是一致的。

术语定义

术语	英文单词	描述
共享变量		在多个线程之间能够被共享的变量被称为共享变量。共享变量包括所有的实例变量，静态变量和数组元素。他们都被存放在堆内存中，Volatile只作用于共享变量。
内存屏障	Memory Barriers	是一组处理器指令，用于实现对内存操作的顺序限制。
缓冲行	Cache line	缓存中可以分配的最小存储单位。处理器填写缓存线时会加载整个缓存线，需要使用多个主内存读周期。
原子操作	Atomic operations	不可中断的一个或一系列操作。
缓存行填充	cache line fill	当处理器识别到从内存中读取操作数是可缓存的，处理器读取整个缓存行到适当的缓存（L1，L2，L3的或所有）
缓存命中	cache hit	如果进行高速缓存行填充操作的内存位置仍然是下次处理器访问的地址时，处理器从缓存中读取操作数，而不是从内存。
写命中	write hit	当处理器将操作数写回到一个内存缓存的区域时，它首先会检查这个缓存的内存地址是否在缓存行中，如果存在一个有效的缓存行，则处理器将这个操作数写回到缓存，而不是写回到内存，这个操作被称为写命中。
写缺失	write misses the cache	一个有效的缓存行被写入到不存在的内存区域。

实现原理

有volatile变量修饰的共享变量进行写操作的时候会将当前处理器缓存行的数据写回到系统内存中，这个写回内存的操作会引起其它CPU里缓存的该内存地址的数据无效。具体实现细节参考这篇文章聊聊并发（一）深入分析Volatile的实现原理。

二、适用场景

volatile具有sychronized的可见性和有序性，但是不具备原子性。volatile的可见性确保了所有线程看到volatile声明的共享变量值是最新的。另外在访问volatile声明的变量时线程不会加锁，也就不会引起线程的阻塞，这就使得相对于sychronized来说它只是轻量级的同步机制。在某些情况下，如果读操作远远大于写操作时，使用volatile能够在性能上优于锁。举个volatile不具备原子性的例子：

2.1 volatile非原子性代码示例(不要这样做)

package com.game.lll.syn;  
  
/** 
 * Volatile不具备原子性 
 * @author liulongling 
 * 
 */  
class VolatileExample3{  
  
    private volatile int count;  
      
    public void inc()  
    {  
        count++;  
    }  
  
  
    public static void main(String[] args) {  
        final VolatileExample3 test = new VolatileExample3();  
        for(int i=0;i<100000;i++){  
            new Thread(){  
                public void run() {  
                    test.inc();  
                };  
            }.start();  
        }  
  
        while(Thread.activeCount()>1)  //保证前面的线程都执行完  
            Thread.yield();  
        System.out.println("count:"+test.count);  
    }  
}  

控制台输出：

count:99994

Volatile不具备原子性：在代码第六行虽然使用了volatile来修饰count，但是从结果可以看出count++的次数等于99994，而我们预期的结果是100000.所以volatile不足以使自增count++原子化，除非你能保证只有一个线程对变量执行写操作。在上一篇文章中：原子性(一) 我对出现这种结果做过原因分析。

2.2 模式一：状态标志

package com.game.lll.syn;  
  
class VolatileExample2{  
    private volatile boolean isShuttingDown = false;   // 标志服务是否正在关闭  
      
    public boolean isShuttingDown() {  
        return isShuttingDown;  
    }  
  
    public void userLogin()  
    {  
        if(isShuttingDown)  
        {  
            // 正在关服，拒绝登陆  
            return;  
        }  
        if(!isShuttingDown)  
        {  
            shutdown();  
        }  
        System.out.println(Thread.currentThread()+"玩家登录");  
    }  
    /** 
     * 关闭服务(断开所有与玩家的连接并且不接受新玩家连接，保存数据，关闭程序) 
     */  
    private void shutdown() {  
        // 停服处理  
        // 将在线玩家踢下线，并在关服过程中不接受新登陆需求  
        isShuttingDown = true;  
        System.out.println(Thread.currentThread()+"关闭服务器");  
    }  
  
    public static void main(String[] args) {  
        final VolatileExample2 test = new VolatileExample2();  
        for(int i=0;i<100000;i++){  
            new Thread(){  
                public void run() {  
                    test.userLogin();  
                };  
            }.start();  
        }  
  
        while(Thread.activeCount()>1)  //保证前面的线程都执行完  
            Thread.yield();  
    }  
}  

控制台输出：

Thread[Thread-0,5,main]关闭服务器
Thread[Thread-0,5,main]玩家登录

在游戏停服处理时，我们会声明一个volatile修饰的bool变量。在上面例子已经证明volatile不具有原子性，那么在运行过程中可能会出现当线程一在执行userLogin()过程中，线程二调用了shutdown()将isShuttingDown布尔变量设置为true。这时如果使用volatile ，线程二会马上通知线程一isShuttingDown的状态发生改变。

2.3 模式二：开销较低的“读-写锁” 策略

public synchronized void inc()  
{  
    count++;  
}  

控制台输出：

count:100000

在读操作多余写操作时，我们可以使用synchronized来保证inc的操作是原子的，并使用volatile保证当前结果的可见性。这样的策略不用每次在读取count变量时只允许一个线程访问它，使得在性能上支持多线程的volatile性能更好一些。

另外volatile还适应以下三个场景，详细参考文章：http://blog.csdn.net/vking_wang/article/details/9982709#t5

只有满足下面所有的标准后，你才能使用volatile变量：

• 写入变量时并不依赖变量的当前值；或者能够确保只有单一的线程改变变量的值。
• 变量不需要与其他的状态变量共同参与不变约束
• 访问变量时，没有其它的原因需要加锁

作者：小毛驴，一个Java游戏服务器开发者　原文地址：https://liulongling.github.io/