volatile关键字

Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个变量的拷贝（虽然对象以及成员变量分配的内存是在共享内存中的，但是每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行，这是现代多核处理器的一个显著特性），所以程序在执行过程中，一个线程看到的变量并不一定是最新的。

关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。

 

volatile自身的特性

?

1 2 3 4 5 6 7 8 9 10 11 12

class VolatileFeaturesExample {     volatile long vl = 0L;                       //使用volatile声明64位的long型变量     public void set(long l) {         vl = l;                                  //单个volatile变量的写     }     public void getAndIncrement () {         vl++;                                    //复合（多个）volatile变量的读/写     }     public long get() {         return vl;                               //单个volatile变量的读     } }

假设有多个线程分别调用上面程序的3个方法，这个程序在语义上和下面程序等价。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class VolatileFeaturesExample {     long vl = 0L;                                //64位的long型普通变量     public synchronized void set(long l) {       //对单个的普通变量的写用同一个锁同步         vl = l;     }     public void getAndIncrement () {             //普通方法调用         long temp = get();                       //调用已同步的读方法         temp += 1L;                              //普通写操作         set(temp);                               //调用已同步的写方法     }     public synchronized long get() {             //对单个的普通变量的读用同一个锁同步             return vl;     } }

如上面示例程序所示，一个volatile变量的单个读/写操作，与使用同一个锁来同步一个普通变量的读/写操作，它们之间的执行效果相同。

锁的happens-before规则保证释放锁和获取锁的两个线程之间的内存可见性，这意味着对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。

锁的语义决定了临界区代码的执行具有原子性。这意味着，即使是64位的long型和double型变量，只要它是volatile变量，对该变量的读/写就具有原子性。如果是多个volatile操作或类似于volatile++这种复合操作，这些操作整体上不具有原子性。

简而言之，volatile变量自身具有下列特性。

❑ 可见性。对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。

❑ 原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性。

 

volatile happen-before的传递性

上面讲的是volatile变量自身的特性，对程序员来说，volatile对线程的内存可见性的影响比volatile自身的特性更为重要，也更需要我们去关注。

从JSR-133开始（即从JDK5开始），volatile变量的写-读可以实现线程之间的通信。

从内存语义的角度来说，volatile的写-读与锁的释放-获取有相同的内存效果：volatile写和锁的释放有相同的内存语义；volatile读与锁的获取有相同的内存语义。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class VolatileExample {     int a = 0;     volatile boolean flag = false;     public void writer() {         a = 1; //1         flag = true; //2     }     public void reader() {         if (flag) { //3             int i = a; //4             //……         }     } }

假设线程A执行writer()方法之后，线程B执行reader()方法。根据happens-before规则，这个过程建立的happens-before关系可以分为3类：

1）根据程序次序规则，1 happens-before 2;3 happens-before 4。

2）根据volatile规则，2 happens-before 3。

3）根据happens-before的传递性规则，1 happens-before 4。

上述happens-before关系的图形化表现形式如下

 

这里A线程写一个volatile变量后，B线程读同一个volatile变量。A线程在写volatile变量之前所有可见的共享变量，在B线程读同一个volatile变量后，将立即变得对B线程可见。

 

volatile写-读的内存语义

volatile写的内存语义如下。当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存。

volatile读的内存语义如下。当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

如果我们把volatile写和volatile读两个步骤综合起来看的话，在读线程B读一个volatile变量后，写线程A在写这个volatile变量之前所有可见的共享变量的值都将立即变得对读线程B可见。

 

注:

由于volatile仅仅保证对单个volatile变量的读/写具有原子性，而锁的互斥执行的特性可以确保对整个临界区代码的执行具有原子性。在功能上，锁比volatile更强大；在可伸缩性和执行性能上，volatile更有优势。如果读者想在程序中用volatile代替锁，请一定谨慎

 

 

 

 

参考: Java并发编程的艺术 4.3.1 volatile和synchronized关键字