Principle analysis of volatile and lock in java
- 2020-06-15 09:07:47
- OfStack
Principle analysis of volatile and lock in java
volatile and lock are two mechanisms for thread cooperative synchronization in Java.
Volatile
volatile is one of the key words in Java
Ensure visibility of variables Prevent reordering Ensures that 64-bit variables (long, double) are read and written atomicallyvolatile is stated in the Java language specification
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.
The Java memory model specifies the ES29en-ES30en effect of volatile, and the write operation of volatile variable happen-ES33en is followed by a read. This way the volatile variable ensures that changes made by one thread are visible to other threads. Since volatile cannot guarantee atomicity, it cannot be used in scenarios with constraints or posterior conditions, such as i++. The common scenario is that stop variable ensures that the system stops being visible to other threads, and double-ES39en lock singleton prevents reordering to ensure safe publication.
Take the following code for example
public class TestVolatile {
private static volatile boolean stop = false;
public static void main(String[] args) {
stop = true;
boolean b = stop;
}
}
When the stop field is declared as volatile, the ACC_VOLATILE position of its variable in the compiled bytecode access_flag is 1.
The key bytecode content is as follows
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
}
View the assembly code generated by the virtual machine through hsdis.
The test environment was java version "1.8.0_45",MACOS10.12.1 i386:x86-64
Add on the execution parameter
-XX:+UnlockDiagnosticVMOptions
-XX:+LogCompilation
-XX:+PrintAssembly
-Xcomp
-XX:CompileCommand=dontinline,*TestVolatile.main
-XX:CompileCommand=compileonly,*TestVolatile.main
View the assembly instruction result for the main method
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]
You can see that lock addl $0x0,(%rsp) has been added to stop after mov %dil,0x68(%rsi)
The description of lock in IA32 is
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 assertedlock is used for exclusive use of Shared memory when instructions are executed in multiple processors. The side effect is the ability to flush the contents of the current processor's cache into memory and invalidate the caches of other processors. It also provides the effect that ordered instructions cannot cross this memory barrier.
Lock
The key to the lock provided in Java is synchronized and can be added to a method block or to a method declaration.
The role of the synchronized keyword is to set up an exclusive access critical section. Before entering this critical section, the corresponding monitor lock should be obtained. Any Java object can be a monitor lock.
synchronized provides atomicity, visibility and guarantees against reordering.
The release operation of the monitor lock is defined in JMM es116EN-before and the subsequent acquisition of the same monitor lock. Combined with program order rules, memory transfer visibility guarantees can be formed.
Look at the implementation at each level in 1 section of code
public class TestSynchronize {
private int count;
private void inc() {
synchronized (this) {
count++;
}
}
public static void main(String[] args) {
new TestSynchronize().inc();
}
}
The bytecode of the compiled inc method is
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
Two JVM bytecode instructions, monitorenter and monitorexist, added before and after the synchronized block, take the this reference as an argument.
The treatment of monitor_enter and monitor_exit in hotspot is
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);
}
The assembly code output by inc method on this machine is
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]lock cmpxchg is Compare And Exchange
public class TestVolatile {
private static volatile boolean stop = false;
public static void main(String[] args) {
stop = true;
boolean b = stop;
}
}
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.
Thank you for reading, I hope to help you, thank you for your support to this site!