volatile关键字解析

转载自:http://www.cnblogs.com/Mainz/p/3556430.html

在上篇《非阻塞同步算法与CAS(Compare and Swap)无锁算法》中讲到在Java中long赋值不是原子操作,因为先写32位,再写后32位,分两步操作,而AtomicLong赋值是原子操作,为什么?为什么volatile能替代简单的锁,却不能保证原子性?这里面涉及volatile,是java中的一个我觉得这个词在Java规范中从未被解释清楚的神奇关键词,在Sun的JDK官方文档是这样形容volatile的:

The Java programming language provides a second mechanism, volatile fields, that is more convenient than locking for some purposes. A field may be declared volatile, in which case the Java Memory Model ensures that all threads see a consistent value for the variable.

意思就是说,如果一个变量加了volatile关键字,就会告诉编译器和JVM的内存模型:这个变量是对所有线程共享的、可见的,每次jvm都会读取最新写入的值并使其最新值在所有CPU可见。volatile似乎是有时候可以代替简单的锁,似乎加了volatile关键字就省掉了锁。但又说volatile不能保证原子性(java程序员很熟悉这句话:volatile仅仅用来保证该变量对所有线程的可见性,但不保证原子性)。这不是互相矛盾吗?

不要将volatile用在getAndOperate场合,仅仅set或者get的场景是适合volatile的

不要将volatile用在getAndOperate场合(这种场合不原子,需要再加锁),仅仅set或者get的场景是适合volatile的

volatile没有原子性举例:AtomicInteger自增

例如你让一个volatile的integer自增(i++),其实要分成3步:1)读取volatile变量值到local; 2)增加变量的值;3)把local的值写回,让其它的线程可见。这3步的jvm指令为:

1
2
3
4
mov    0xc (%r10),%r8d ; Load
inc    %r8d           ; Increment
mov    %r8d, 0xc (%r10) ; Store
lock addl $ 0x0 ,(%rsp) ; StoreLoad Barrier

注意最后一步是内存屏障。

什么是内存屏障(Memory Barrier)?

内存屏障(memory barrier)是一个CPU指令。基本上,它是这样一条指令: a) 确保一些特定操作执行的顺序; b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序,使性能得到优化。插入一个内存屏障,相当于告诉CPU和编译器先于这个命令的必须先执行,后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如,一个写屏障会把这个屏障前写入的数据刷新到缓存,这样任何试图读取该数据的线程将得到最新值,而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。

内存屏障(memory barrier)和volatile什么关系?上面的虚拟机指令里面有提到,如果你的字段是volatile,Java内存模型将在写操作后插入一个写屏障指令,在读操作前插入一个读屏障指令。这意味着如果你对一个volatile字段进行写操作,你必须知道:1、一旦你完成写入,任何访问这个字段的线程将会得到最新的值。2、在你写入前,会保证所有之前发生的事已经发生,并且任何更新过的数据值也是可见的,因为内存屏障会把之前的写入值都刷新到缓存。

volatile为什么没有原子性?

明白了内存屏障(memory barrier)这个CPU指令,回到前面的JVM指令:从Load到store到内存屏障,一共4步,其中最后一步jvm让这个最新的变量的值在所有线程可见,也就是最后一步让所有的CPU内核都获得了最新的值,但中间的几步(从Load到Store)是不安全的,中间如果其他的CPU修改了值将会丢失。下面的测试代码可以实际测试voaltile的自增没有原子性:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
     private  static  volatile  long  _longVal = 0 ;
     
     private  static  class  LoopVolatile implements  Runnable {
         public  void  run() {
             long  val = 0 ;
             while  (val < 10000000L) {
                 _longVal++;
                 val++;
             }
         }
     }
     
     private  static  class  LoopVolatile2 implements  Runnable {
         public  void  run() {
             long  val = 0 ;
             while  (val < 10000000L) {
                 _longVal++;
                 val++;
             }
         }
     }
     
     private   void  testVolatile(){
         Thread t1 = new  Thread( new  LoopVolatile());
         t1.start();
         
         Thread t2 = new  Thread( new  LoopVolatile2());
         t2.start();
         
         while  (t1.isAlive() || t2.isAlive()) {
         }
 
         System.out.println( "final val is: "  + _longVal);
     }
 
Output:-------------
     
final  val is: 11223828
final  val is: 17567127
final  val is: 12912109
volatile没有原子性举例:singleton单例模式实现

这是一段线程不安全的singleton(单例模式)实现,尽管使用了volatile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public  class  wrongsingleton {
     private  static  volatile  wrongsingleton _instance = null ;
 
     private  wrongsingleton() {}
 
     public  static  wrongsingleton getInstance() {
 
         if  (_instance == null ) {
             _instance = new  wrongsingleton();
         }
 
         return  _instance;
     }
}

下面的测试代码可以测试出是线程不安全的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public  class  wrongsingleton {
     private  static  volatile  wrongsingleton _instance = null ;
 
     private  wrongsingleton() {}
 
     public  static  wrongsingleton getInstance() {
 
         if  (_instance == null ) {
             _instance = new  wrongsingleton();
             System.out.println( "--initialized once." );
         }
 
         return  _instance;
     }
}
 
private  static  void  testInit(){
         
         Thread t1 = new  Thread( new  LoopInit());
         Thread t2 = new  Thread( new  LoopInit2());
         Thread t3 = new  Thread( new  LoopInit());
         Thread t4 = new  Thread( new  LoopInit2());
         t1.start();
         t2.start();
         t3.start();
         t4.start();
         
         while  (t1.isAlive() || t2.isAlive() || t3.isAlive()|| t4.isAlive()) {
             
         }
 
     }
输出:有时输出 "--initialized once." 一次,有时输出好几次

原因自然和上面的例子是一样的。因为volatile保证变量对线程的可见性,但不保证原子性

附:正确线程安全的单例模式写法:

1
2
3
4
5
6
7
8
9
@ThreadSafe
public  class  SafeLazyInitialization {
    private  static  Resource resource;
    public  synchronized  static  Resource getInstance() {
       if  (resource == null )
           resource = new  Resource();
       return  resource;
     }
}

另外一种写法:

1
2
3
4
5
@ThreadSafe
public  class  EagerInitialization {
   private  static  Resource resource = new  Resource();
   public  static  Resource getResource() { return  resource; }
}

延迟初始化的写法:

1
2
3
4
5
6
7
8
9
@ThreadSafe
public  class  ResourceFactory {
     private  static  class  ResourceHolder {
         public  static  Resource resource = new  Resource();
     }
     public  static  Resource getResource() {
         return  ResourceHolder.resource ;
     }
}

二次检查锁定/Double Checked Locking的写法(反模式)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public  class  SingletonDemo {
     private  static  volatile  SingletonDemo instance = null ; //注意需要volatile
  
     private  SingletonDemo() {   }
  
     public  static  SingletonDemo getInstance() {
         if  (instance == null ) { //二次检查,比直接用独占锁效率高
                synchronized  (SingletonDemo . class ){
                     if  (instance == null ) {
                                instance = new  SingletonDemo ();
                     }
              }
         }
         return  instance;
     }
}
为什么AtomicXXX具有原子性和可见性?

就拿AtomicLong来说,它既解决了上述的volatile的原子性没有保证的问题,又具有可见性。它是如何做到的?当然就是上文《非阻塞同步算法与CAS(Compare and Swap)无锁算法》提到的CAS(比较并交换)指令。 其实AtomicLong的源码里也用到了volatile,但只是用来读取或写入,见源码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public  class  AtomicLong extends  Number implements  java.io.Serializable {
     private  volatile  long  value;
 
     /**
      * Creates a new AtomicLong with the given initial value.
      *
      * @param initialValue the initial value
      */
     public  AtomicLong( long  initialValue) {
         value = initialValue;
     }
 
     /**
      * Creates a new AtomicLong with initial value {@code 0}.
      */
     public  AtomicLong() {
     }

其CAS源码核心代码为:

1
2
3
4
5
6
7
8
9
int  compare_and_swap ( int * reg, int  oldval, int  newval)
{
   ATOMIC();
   int  old_reg_val = *reg;
   if  (old_reg_val == oldval)
      *reg = newval;
   END_ATOMIC();
   return  old_reg_val;
}

虚拟机指令为:

1
2
3
4
mov    0xc (%r11),%eax       ; Load
mov    %eax,%r8d           
inc    %r8d                 ; Increment
lock cmpxchg %r8d, 0xc (%r11) ; Compare and exchange

因为CAS是基于乐观锁的,也就是说当写入的时候,如果寄存器旧值已经不等于现值,说明有其他CPU在修改,那就继续尝试。所以这就保证了操作的原子性。

ConcurrencyCAS

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值