What is Java Synchronized

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

Constant pool:
   #1 = Methodref          #7.#26         // java/lang/Object."":()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              
  #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              
  #24 = Utf8               SourceFile
  #25 = Utf8               Demo1.java
  #26 = NameAndType        #13:#14        // "":()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.

The difference between Synchronized and ReentrantLock

This is a very common interview question, and it is asked very frequently in interviews

Similarities:

Both It is the implementation of mutex lock

The 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).

• 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!