java 中volatile和lock原理分析

更新時(shí)間：2017年03月29日 09:01:43 作者：劉正陽

這篇文章主要介紹了java 中volatile和lock原理分析的相關(guān)資料,需要的朋友可以參考下

java 中volatile和lock原理分析

volatile和lock是Java中用于線程協(xié)同同步的兩種機(jī)制。

Volatile

volatile是Java中的一個(gè)關(guān)鍵字，它的作用有

保證變量的可見性
防止重排序
保證64位變量(long，double)的原子性讀寫

volatile在Java語言規(guī)范中規(guī)定的是

The Java programming language allows threads to access shared variables (§17.1). As a rule, to ensure 
that shared variables are consistently and reliably updated, a thread should ensure that it
 has exclusive use of such variables by obtaining a lock that, conventionally, enforces mutual 
exclusion for those shared variables.
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 .
It is a compile-time error if a final variable is also declared volatile.

Java內(nèi)存模型中規(guī)定了volatile的happen-before效果，對(duì)volatile變量的寫操作happen-before于后續(xù)的讀。這樣volatile變量能夠確保一個(gè)線程的修改對(duì)其他線程可見。volatile因?yàn)椴荒鼙ＷC原子性，所以不能在有約束或后驗(yàn)條件的場景下使用，如i++,常用的場景是stop變量保證系統(tǒng)停止對(duì)其他線程可見，double-check lock單例中防止重排序來保證安全發(fā)布等。

以下面這段代碼為例

public class TestVolatile {
  private static volatile boolean stop = false;
  public static void main(String[] args) {
    stop = true;
    boolean b = stop;
  }
}

stop字段聲明為volatile類型后，編譯后的字節(jié)碼中其變量的access_flag中ACC_VOLATILE位置為1。

關(guān)鍵的字節(jié)碼內(nèi)容如下

 public static void main(java.lang.String[]);
  descriptor: ([Ljava/lang/String;)V
  flags: ACC_PUBLIC, ACC_STATIC
  Code:
   stack=1, locals=2, args_size=1
     0: iconst_1
     1: putstatic   #2         // Field stop:Z
     4: getstatic   #2         // Field stop:Z
     7: istore_1
     8: return
   LineNumberTable:
    line 14: 0
    line 15: 4
    line 16: 8
   LocalVariableTable:
    Start Length Slot Name  Signature
      0    9   0 args  [Ljava/lang/String;
      8    1   1   b  Z
 static {};
  descriptor: ()V
  flags: ACC_STATIC
  Code:
   stack=1, locals=0, args_size=0
     0: iconst_0
     1: putstatic   #2         // Field stop:Z
     4: return
   LineNumberTable:
    line 11: 0
}

通過hsdis查看虛擬機(jī)產(chǎn)生的匯編代碼。

測試環(huán)境為java version “1.8.0_45”,MACOS10.12.1 i386:x86-64

在執(zhí)行參數(shù)上添加

-XX:+UnlockDiagnosticVMOptions
-XX:+LogCompilation
-XX:+PrintAssembly
-Xcomp
-XX:CompileCommand=dontinline,*TestVolatile.main
-XX:CompileCommand=compileonly,*TestVolatile.main

查看main方法的匯編指令結(jié)果

Decoding compiled method 0x000000010c732c50:
Code:
[Disassembling for mach='i386:x86-64']
[Entry Point]
[Verified Entry Point]
[Constants]
 # {method} {0x000000012422a2c8} 'main' '([Ljava/lang/String;)V' in 'com/concurrent/volatiles/TestVolatile'
 # parm0:  rsi:rsi  = '[Ljava/lang/String;'
 #      [sp+0x40] (sp of caller)
 0x000000010c732da0: mov  %eax,-0x14000(%rsp)
 0x000000010c732da7: push  %rbp
 0x000000010c732da8: sub  $0x30,%rsp
 0x000000010c732dac: movabs $0x12422a448,%rdi ;  {metadata(method data for {method} {0x000000012422a2c8} 'main' '([Ljava/lang/String;)V' in 'com/concurrent/volatiles/TestVolatile')}
 0x000000010c732db6: mov  0xdc(%rdi),%ebx
 0x000000010c732dbc: add  $0x8,%ebx
 0x000000010c732dbf: mov  %ebx,0xdc(%rdi)
 0x000000010c732dc5: movabs $0x12422a2c8,%rdi ;  {metadata({method} {0x000000012422a2c8} 'main' '([Ljava/lang/String;)V' in 'com/concurrent/volatiles/TestVolatile')}
 0x000000010c732dcf: and  $0x0,%ebx
 0x000000010c732dd2: cmp  $0x0,%ebx
 0x000000010c732dd5: je   0x000000010c732e03 ;*iconst_1
                        ; - com.concurrent.volatiles.TestVolatile::main@0 (line 14)
 0x000000010c732ddb: movabs $0x76adce798,%rsi ;  {oop(a 'java/lang/Class' = 'com/concurrent/volatiles/TestVolatile')}
 0x000000010c732de5: mov  $0x1,%edi
 0x000000010c732dea: mov  %dil,0x68(%rsi)
 0x000000010c732dee: lock addl $0x0,(%rsp)   ;*putstatic stop
                        ; - com.concurrent.volatiles.TestVolatile::main@1 (line 14)
 0x000000010c732df3: movsbl 0x68(%rsi),%esi  ;*getstatic stop
                        ; - com.concurrent.volatiles.TestVolatile::main@4 (line 15)
 0x000000010c732df7: add  $0x30,%rsp
 0x000000010c732dfb: pop  %rbp
 0x000000010c732dfc: test  %eax,-0x3adbd02(%rip)    # 0x0000000108c57100
                        ;  {poll_return}
 0x000000010c732e02: retq  
 0x000000010c732e03: mov  %rdi,0x8(%rsp)
 0x000000010c732e08: movq  $0xffffffffffffffff,(%rsp)
 0x000000010c732e10: callq 0x000000010c7267e0 ; OopMap{rsi=Oop off=117}
                        ;*synchronization entry
                        ; - com.concurrent.volatiles.TestVolatile::main@-1 (line 14)
                        ;  {runtime_call}
 0x000000010c732e15: jmp  0x000000010c732ddb
 0x000000010c732e17: nop
 0x000000010c732e18: nop
 0x000000010c732e19: mov  0x2a8(%r15),%rax
 0x000000010c732e20: movabs $0x0,%r10
 0x000000010c732e2a: mov  %r10,0x2a8(%r15)
 0x000000010c732e31: movabs $0x0,%r10
 0x000000010c732e3b: mov  %r10,0x2b0(%r15)
 0x000000010c732e42: add  $0x30,%rsp
 0x000000010c732e46: pop  %rbp
 0x000000010c732e47: jmpq  0x000000010c6940e0 ;  {runtime_call}  
[Exception Handler]

可以看到在mov %dil,0x68(%rsi)給stop賦值后增加了lock addl $0x0,(%rsp)

IA32中對(duì)lock的說明是

The LOCK # signal is asserted during execution of the instruction following 
the lock prefix. This signal can be used in a multiprocessor system to ensure 
exclusive use of shared memory while LOCK # is asserted

lock用于在多處理器中執(zhí)行指令時(shí)對(duì)共享內(nèi)存的獨(dú)占使用。它的副作用是能夠?qū)?dāng)前處理器對(duì)應(yīng)緩存的內(nèi)容刷新到內(nèi)存，并使其他處理器對(duì)應(yīng)的緩存失效。另外還提供了有序的指令無法越過這個(gè)內(nèi)存屏障的作用。

Lock

Java中提供的鎖的關(guān)鍵字是synchronized, 可以加在方法塊上，也可以加在方法聲明中。

synchronized關(guān)鍵字起到的作用是設(shè)置一個(gè)獨(dú)占訪問臨界區(qū)，在進(jìn)入這個(gè)臨界區(qū)前要先獲取對(duì)應(yīng)的監(jiān)視器鎖，任何Java對(duì)象都可以成為監(jiān)視器鎖，聲明在靜態(tài)方法上時(shí)監(jiān)視器鎖是當(dāng)前類的Class對(duì)象，實(shí)例方法上是當(dāng)前實(shí)例。
synchronized提供了原子性、可見性和防止重排序的保證。

JMM中定義監(jiān)視器鎖的釋放操作happen-before與后續(xù)的同一個(gè)監(jiān)視器鎖獲取操作。再結(jié)合程序順序規(guī)則就可以形成內(nèi)存?zhèn)鬟f可見性保證。

下面以一段代碼查看各個(gè)層次的實(shí)現(xiàn)

public class TestSynchronize {
  private int count;
  private void inc() {
    synchronized (this) {
      count++;
    }
  }
  public static void main(String[] args) {
    new TestSynchronize().inc();
  }
}

編譯后inc方法的字節(jié)碼為

private void inc();
  descriptor: ()V
  flags: ACC_PRIVATE
  Code:
   stack=3, locals=3, args_size=1
    0: aload_0
    1: dup
    2: astore_1
    3: monitorenter
    4: aload_0
    5: dup
    6: getfield   #2         // Field count:I
    9: iconst_1
    10: iadd
    11: putfield   #2         // Field count:I
    14: aload_1
    15: monitorexit
    16: goto     24
    19: astore_2
    20: aload_1
    21: monitorexit
    22: aload_2
    23: athrow
    24: return
   Exception table:
    from  to target type
      4  16  19  any
      19  22  19  any
   LineNumberTable:
    line 14: 0
    line 15: 4

在synchronized代碼塊前后增加的monitorenter和monitorexist兩個(gè)JVM字節(jié)碼指令,指令的參數(shù)是this引用。

hotspot中對(duì)于monitor_enter和monitor_exit的處理是

void LIRGenerator::monitor_enter(LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no, CodeEmitInfo* info_for_exception, CodeEmitInfo* info) {
 if (!GenerateSynchronizationCode) return;
 // for slow path, use debug info for state after successful locking
 CodeStub* slow_path = new MonitorEnterStub(object, lock, info);
 __ load_stack_address_monitor(monitor_no, lock);
 // for handling NullPointerException, use debug info representing just the lock stack before this monitorenter
 __ lock_object(hdr, object, lock, scratch, slow_path, info_for_exception);
}
void LIRGenerator::monitor_exit(LIR_Opr object, LIR_Opr lock, LIR_Opr new_hdr, LIR_Opr scratch, int monitor_no) {
 if (!GenerateSynchronizationCode) return;
 // setup registers
 LIR_Opr hdr = lock;
 lock = new_hdr;
 CodeStub* slow_path = new MonitorExitStub(lock, UseFastLocking, monitor_no);
 __ load_stack_address_monitor(monitor_no, lock);
 __ unlock_object(hdr, object, lock, scratch, slow_path);
}

inc方法在本機(jī)上輸出的匯編代碼為

Decoding compiled method 0x0000000115be3e50:
Code:
[Entry Point]
[Constants]
 # {method} {0x0000000113082328} 'inc' '()V' in 'com/concurrent/lock/TestSynchronize'
 #      [sp+0x50] (sp of caller)
 0x0000000115be3fc0: mov  0x8(%rsi),%r10d
 0x0000000115be3fc4: shl  $0x3,%r10
 0x0000000115be3fc8: cmp  %rax,%r10
 0x0000000115be3fcb: jne  0x0000000115b1de20 ;  {runtime_call}
 0x0000000115be3fd1: data32 data32 nopw 0x0(%rax,%rax,1)
 0x0000000115be3fdc: data32 data32 xchg %ax,%ax
[Verified Entry Point]
 0x0000000115be3fe0: mov  %eax,-0x14000(%rsp)
 0x0000000115be3fe7: push  %rbp
 0x0000000115be3fe8: sub  $0x40,%rsp
 0x0000000115be3fec: movabs $0x113082848,%rax ;  {metadata(method data for {method} {0x0000000113082328} 'inc' '()V' in 'com/concurrent/lock/TestSynchronize')}
 0x0000000115be3ff6: mov  0xdc(%rax),%edi
 0x0000000115be3ffc: add  $0x8,%edi
 0x0000000115be3fff: mov  %edi,0xdc(%rax)
 0x0000000115be4005: movabs $0x113082328,%rax ;  {metadata({method} {0x0000000113082328} 'inc' '()V' in 'com/concurrent/lock/TestSynchronize')}
 0x0000000115be400f: and  $0x0,%edi
 0x0000000115be4012: cmp  $0x0,%edi
 0x0000000115be4015: je   0x0000000115be418d ;*aload_0
                        ; - com.concurrent.lock.TestSynchronize::inc@0 (line 14)
 0x0000000115be401b: lea  0x20(%rsp),%rdi
 0x0000000115be4020: mov  %rsi,0x8(%rdi)
 0x0000000115be4024: mov  (%rsi),%rax
 0x0000000115be4027: mov  %rax,%rbx
 0x0000000115be402a: and  $0x7,%rbx
 0x0000000115be402e: cmp  $0x5,%rbx
 0x0000000115be4032: jne  0x0000000115be40b9
 0x0000000115be4038: mov  0x8(%rsi),%ebx
 0x0000000115be403b: shl  $0x3,%rbx
 0x0000000115be403f: mov  0xa8(%rbx),%rbx
 0x0000000115be4046: or   %r15,%rbx
 0x0000000115be4049: xor  %rax,%rbx
 0x0000000115be404c: and  $0xffffffffffffff87,%rbx
 0x0000000115be4050: je   0x0000000115be40e1
 0x0000000115be4056: test  $0x7,%rbx
 0x0000000115be405d: jne  0x0000000115be40a6
 0x0000000115be405f: test  $0x300,%rbx
 0x0000000115be4066: jne  0x0000000115be4085
 0x0000000115be4068: and  $0x37f,%rax
 0x0000000115be406f: mov  %rax,%rbx
 0x0000000115be4072: or   %r15,%rbx
 0x0000000115be4075: lock cmpxchg %rbx,(%rsi)
 0x0000000115be407a: jne  0x0000000115be41a4
 0x0000000115be4080: jmpq  0x0000000115be40e1
 0x0000000115be4085: mov  0x8(%rsi),%ebx
 0x0000000115be4088: shl  $0x3,%rbx
 0x0000000115be408c: mov  0xa8(%rbx),%rbx
 0x0000000115be4093: or   %r15,%rbx
 0x0000000115be4096: lock cmpxchg %rbx,(%rsi)
 0x0000000115be409b: jne  0x0000000115be41a4
 0x0000000115be40a1: jmpq  0x0000000115be40e1
 0x0000000115be40a6: mov  0x8(%rsi),%ebx
 0x0000000115be40a9: shl  $0x3,%rbx
 0x0000000115be40ad: mov  0xa8(%rbx),%rbx
 0x0000000115be40b4: lock cmpxchg %rbx,(%rsi)
 0x0000000115be40b9: mov  (%rsi),%rax
 0x0000000115be40bc: or   $0x1,%rax
 0x0000000115be40c0: mov  %rax,(%rdi)
 0x0000000115be40c3: lock cmpxchg %rdi,(%rsi)
 0x0000000115be40c8: je   0x0000000115be40e1
 0x0000000115be40ce: sub  %rsp,%rax
 0x0000000115be40d1: and  $0xfffffffffffff007,%rax
 0x0000000115be40d8: mov  %rax,(%rdi)
 0x0000000115be40db: jne  0x0000000115be41a4 ;*monitorenter
                        ; - com.concurrent.lock.TestSynchronize::inc@3 (line 14)
 0x0000000115be40e1: mov  0xc(%rsi),%eax   ;*getfield count
                        ; - com.concurrent.lock.TestSynchronize::inc@6 (line 15)
 0x0000000115be40e4: inc  %eax
 0x0000000115be40e6: mov  %eax,0xc(%rsi)   ;*putfield count
                        ; - com.concurrent.lock.TestSynchronize::inc@11 (line 15)
 0x0000000115be40e9: lea  0x20(%rsp),%rax
 0x0000000115be40ee: mov  0x8(%rax),%rdi
 0x0000000115be40f2: mov  (%rdi),%rsi
 0x0000000115be40f5: and  $0x7,%rsi
 0x0000000115be40f9: cmp  $0x5,%rsi
 0x0000000115be40fd: je   0x0000000115be411a
 0x0000000115be4103: mov  (%rax),%rsi
 0x0000000115be4106: test  %rsi,%rsi
 0x0000000115be4109: je   0x0000000115be411a
 0x0000000115be410f: lock cmpxchg %rsi,(%rdi)
 0x0000000115be4114: jne  0x0000000115be41b7 ;*monitorexit
                        ; - com.concurrent.lock.TestSynchronize::inc@15 (line 16)
 0x0000000115be411a: movabs $0x113082848,%rax ;  {metadata(method data for {method} {0x0000000113082328} 'inc' '()V' in 'com/concurrent/lock/TestSynchronize')}
 0x0000000115be4124: incl  0x108(%rax)    ;*goto
                        ; - com.concurrent.lock.TestSynchronize::inc@16 (line 16)
 0x0000000115be412a: add  $0x40,%rsp
 0x0000000115be412e: pop  %rbp
 0x0000000115be412f: test  %eax,-0x684e035(%rip)    # 0x000000010f396100
                        ;  {poll_return}
 0x0000000115be4135: retq           ;*return
                        ; - com.concurrent.lock.TestSynchronize::inc@24 (line 17)
 0x0000000115be4136: mov  0x2a8(%r15),%rax
 0x0000000115be413d: xor  %r10,%r10
 0x0000000115be4140: mov  %r10,0x2a8(%r15)
 0x0000000115be4147: xor  %r10,%r10
 0x0000000115be414a: mov  %r10,0x2b0(%r15)
 0x0000000115be4151: mov  %rax,%rsi
 0x0000000115be4154: lea  0x20(%rsp),%rax
 0x0000000115be4159: mov  0x8(%rax),%rbx
 0x0000000115be415d: mov  (%rbx),%rdi
 0x0000000115be4160: and  $0x7,%rdi
 0x0000000115be4164: cmp  $0x5,%rdi
 0x0000000115be4168: je   0x0000000115be4185
 0x0000000115be416e: mov  (%rax),%rdi
 0x0000000115be4171: test  %rdi,%rdi
 0x0000000115be4174: je   0x0000000115be4185
 0x0000000115be417a: lock cmpxchg %rdi,(%rbx)
 0x0000000115be417f: jne  0x0000000115be41ca ;*monitorexit
                        ; - com.concurrent.lock.TestSynchronize::inc@21 (line 16)
 0x0000000115be4185: mov  %rsi,%rax
 0x0000000115be4188: jmpq  0x0000000115be4205
 0x0000000115be418d: mov  %rax,0x8(%rsp)
 0x0000000115be4192: movq  $0xffffffffffffffff,(%rsp)
 0x0000000115be419a: callq 0x0000000115bd5be0 ; OopMap{rsi=Oop off=479}
                        ;*synchronization entry
                        ; - com.concurrent.lock.TestSynchronize::inc@-1 (line 14)
                        ;  {runtime_call}
 0x0000000115be419f: jmpq  0x0000000115be401b
 0x0000000115be41a4: mov  %rsi,0x8(%rsp)
 0x0000000115be41a9: mov  %rdi,(%rsp)
 0x0000000115be41ad: callq 0x0000000115bd4060 ; OopMap{rsi=Oop [40]=Oop off=498}
                        ;*monitorenter
                        ; - com.concurrent.lock.TestSynchronize::inc@3 (line 14)
                        ;  {runtime_call}
 0x0000000115be41b2: jmpq  0x0000000115be40e1
 0x0000000115be41b7: lea  0x20(%rsp),%rax
 0x0000000115be41bc: mov  %rax,(%rsp)
 0x0000000115be41c0: callq 0x0000000115bd4420 ;  {runtime_call}
 0x0000000115be41c5: jmpq  0x0000000115be411a
 0x0000000115be41ca: lea  0x20(%rsp),%rax
 0x0000000115be41cf: mov  %rax,(%rsp)
 0x0000000115be41d3: callq 0x0000000115bd4420 ;  {runtime_call}
 0x0000000115be41d8: jmp  0x0000000115be4185
 0x0000000115be41da: nop
 0x0000000115be41db: nop
 0x0000000115be41dc: mov  0x2a8(%r15),%rax
 0x0000000115be41e3: movabs $0x0,%r10
 0x0000000115be41ed: mov  %r10,0x2a8(%r15)
 0x0000000115be41f4: movabs $0x0,%r10
 0x0000000115be41fe: mov  %r10,0x2b0(%r15)
 0x0000000115be4205: add  $0x40,%rsp
 0x0000000115be4209: pop  %rbp
 0x0000000115be420a: jmpq  0x0000000115b440e0 ;  {runtime_call}  
[Exception Handler]

其中l(wèi)ock cmpxchg為Compare And Exchange

CMPXCHG compares its destination (first) operand to the
 value in AL, AX or EAX (depending on the size of the instruction).
 If they are equal, it copies its source (second) operand into the destination
 and sets the zero flag. Otherwise, it clears the zero flag and leaves the destination alone.

CMPXCHG is intended to be used for atomic operations in multitasking or multiprocessor environments. To safely update a value in shared memory, for example, you might load the value into EAX, load the updated value into EBX, and then execute the instruction lock cmpxchg [value],ebx. If value has not changed since being loaded, it is updated with your desired new value, and the zero flag is set to let you know it has worked. (The LOCK prefix prevents another processor doing anything in the middle of this operation: it guarantees atomicity.) However, if another processor has modified the value in between your load and your attempted store, the store does not happen, and you are notified of the failure by a cleared zero flag, so you can go round and try again.

感謝閱讀，希望能幫助到大家，謝謝大家對(duì)本站的支持！

您可能感興趣的文章: