What is Java Synchronized
- WBOYforward
- 2023-05-14 08:28:051711browse
What is Synchronized
Dear Java readers, you are no stranger to the synchronized keyword. It can be seen in various middleware source codes or JDK source codes. For readers who are not familiar with synchronized, they only know that it is used in multi-threading. You need to use the synchronized keyword, knowing that synchronized can ensure thread safety.
Called: Mutex lock (only one thread can execute at the same time, other threads will wait)
Also called : Pessimistic lock (only one thread can execute at the same time, other threads will wait)
The JVM virtual machine will help you implement it. Developers only need to use the synchronized keyword.
When using it, you need to use an object as a lock mutex
It can ensure the atomicity and visibility of a piece of code (critical section).
Analyzing the Synchronized keyword from the bytecode level
It is most appropriate to start with a case.
class Demo1{
// 互斥对象
static Object object = new Object();
// 竞争条件
static int cout = 0;
public static void main(String[] args) {
// 互斥
synchronized(object){
// 以下是临界区
cout++;
System.out.println("synchronized");
}
}
}We can’t tell anything just from the Java code, and the Java program is compiled into a bytecode file, so we parse the bytecode
The difference between Synchronized and ReentrantLockThis is a very common interview question, and it is asked very frequently in interviewsSimilarities:Both It is the implementation of mutex lockThe difference: Synchronized is based on the internal implementation of the JVM, and ReentrantLock is implemented on the Java level (but the core code of ReentrantLock still calls C code).Constant pool:
#1 = Methodref #7.#26 // java/lang/Object."7e51f00a783d7eb8f68358439dee7daf":()V
#2 = Fieldref #8.#27 // Demo1.object:Ljava/lang/Object;
#3 = Fieldref #8.#28 // Demo1.cout:I
#4 = Fieldref #29.#30 // java/lang/System.out:Ljava/io/PrintStream;
#5 = String #31 // synchronized
#6 = Methodref #32.#33 // java/io/PrintStream.println:(Ljava/lang/String;)V
#7 = Class #34 // java/lang/Object
#8 = Class #35 // Demo1
#9 = Utf8 object
#10 = Utf8 Ljava/lang/Object;
#11 = Utf8 cout
#12 = Utf8 I
#13 = Utf8 7e51f00a783d7eb8f68358439dee7daf
#14 = Utf8 ()V
#15 = Utf8 Code
#16 = Utf8 LineNumberTable
#17 = Utf8 main
#18 = Utf8 ([Ljava/lang/String;)V
#19 = Utf8 StackMapTable
#20 = Class #36 // "[Ljava/lang/String;"
#21 = Class #34 // java/lang/Object
#22 = Class #37 // java/lang/Throwable
#23 = Utf8 583d030be372af71281df966e84181a5
#24 = Utf8 SourceFile
#25 = Utf8 Demo1.java
#26 = NameAndType #13:#14 // "7e51f00a783d7eb8f68358439dee7daf":()V
#27 = NameAndType #9:#10 // object:Ljava/lang/Object;
#28 = NameAndType #11:#12 // cout:I
#29 = Class #38 // java/lang/System
#30 = NameAndType #39:#40 // out:Ljava/io/PrintStream;
#31 = Utf8 synchronized
#32 = Class #41 // java/io/PrintStream
#33 = NameAndType #42:#43 // println:(Ljava/lang/String;)V
#34 = Utf8 java/lang/Object
#35 = Utf8 Demo1
#36 = Utf8 [Ljava/lang/String;
#37 = Utf8 java/lang/Throwable
#38 = Utf8 java/lang/System
#39 = Utf8 out
#40 = Utf8 Ljava/io/PrintStream;
#41 = Utf8 java/io/PrintStream
#42 = Utf8 println
#43 = Utf8 (Ljava/lang/String;)V
0: getstatic #2 // 从2号常量池中拿到静态变量，压入到操作数栈中
3: dup // 把操作数栈栈顶的对象赋值一份
4: astore_1 but 5: getstatic #3 // Get the static variable from constant pool No. 2 and push it into the operand stack
9: iconst_1 iconst_1 // Push the constant 1 into the operand stack
10: iadd 10: iadd // Consumption The data of the two operand stacks are added and then pushed onto the top of the stack
11: putstatic #3 //Assign the variable on the top of the operand stack to constant pool No. 3
14: getstatic #4 // Push the object of constant pool No. 4 into the operand stack
17: ldc #5 // Parse the symbol of constant pool 5 and get the string constant "synchronized"
19: invokevirtual #6 // Execute println Function, consumption of 2 operations stack
22: ALOAD_1 // Press the data of the local variable table 1 into the operation number stack
23: Monitorexit // The end of the mutual lock, it is also the byte code level of Synchronized Implementation
24: goto 32 // Jump to line 32.
27: astore_2 to Top of the stack, used by the monitorexit instruction
29: monitorexit // There may be an exception, but the lock needs to be released, otherwise it will be deadlocked.
30: aload_2 to ‐ to 32 to Receive exception to be thrown, // Function returns
The above is a complete explanation of the bytecode. It is actually very simple. Finally, the Synchronized keyword is parsed into monitorenter and monitorexit bytecode instructions, and then each time before executing these two bytecode instructions, The mutex object is pushed onto the operand stack for use by the monitorenter and monitorexit bytecode instructions.
So the next article is to go to the Hotspot source code to parse the detailed process of monitorenter and monitorexit bytecode instructions.
- Synchronized has been optimized after 1.6. There are several different levels of locks. The strength of the lock is increased according to the intensity of thread competition (commonly known as lock upgrade). It is more suitable for scenarios, and ReentrantLock It is a bit rigid in the selection of lock strength.
- Although ReentrantLock is slightly rigid in the choice of lock strength, you can choose between fair and unfair locks, while Synchronized can only be unfair locks
- ReentrantLock's conditional waiting queue can create multiple and highly customized. There is only one queue at the bottom of Synchronized.
- ReentrantLock requires the user to manually open the lock and release the lock manually. The bottom layer of the Synchronized keyword is automatically implemented through bytecode
The above is the detailed content of What is Java Synchronized. For more information, please follow other related articles on the PHP Chinese website!