What are the underlying principles and lock upgrade process of synchronized in Java?

Deepening Java synchronized : Low-level mechanism and lock upgrade

synchronized is an important keyword used for thread synchronization in Java. Its underlying implementation and lock upgrade mechanism are crucial to concurrency performance. This article will explore the operating details of synchronized and analyze the lock upgrade process in combination with sample code.

The following sample code demonstrates the transition of different lock states:

 public static void main(String[] args) throws InterruptedException {
    // There is a 4-second delay after the Hotspot virtual machine starts before the bias lock is enabled Thread.sleep(5000);
    Object obj = new Object();
    System.out.println("Initial status======================================================= "\n" ClassLayout.parseInstance(obj).toPrintable());
    new Thread(() -> {
        synchronized (obj) {
            System.out.println(Thread.currentThread().getName() "Get lock is being executed...\n"
                      ClassLayout.parseInstance(obj).toPrintable());
        }
    }, "Thread A").start();

    Thread.sleep(1000);

    new Thread(() -> {
        synchronized (obj) {
            System.out.println(Thread.currentThread().getName() "Get lock is being executed...\n"
                      ClassLayout.parseInstance(obj).toPrintable());
        }
    }, "Thread B").start();

    // Thread.sleep(5000);
    System.out.println(Thread.currentThread().getName() ClassLayout.parseInstance(obj).toPrintable());
}

Run this code and observe the output results to see the conversion process of the lock state from lockless to biased lock, lightweight lock, and even heavyweight lock (note: the biased lock has been deprecated by the higher version of JVM).

The synchronized lock upgrade process is as follows:

1. Lockless state: the initial state of the object, the object header contains information such as hash code, GC age, etc.
2. Biased locks (deprecated in newer JVM versions): When only one thread accesses a synchronization block, the JVM biases the lock to the thread, and the object header records biased to the thread ID, reducing the overhead of lock acquisition.
3. Lightweight lock: When the second thread tries to acquire the lock, if the thread that biases the lock is not executed in the synchronous block, the bias lock is upgraded to a lightweight lock. The lightweight lock acquires the lock through spin attempts, with limited spins, and if it fails, it upgrades to a heavyweight lock.
4. Heavyweight lock: thread hangs, operating system scheduling, high overhead, suitable for high competition scenarios.

The output of the sample code will show the transition of the lock state, such as from lock-free to lightweight locks, to possible heavyweight locks. (The bias lock status may not be displayed because the bias lock is deprecated). Analyzing these outputs allows you to have a deeper understanding of the dynamic process of lock upgrade.

In short, understanding the underlying mechanism and lock upgrade process of synchronized is crucial to mastering Java concurrent programming and performance optimization. Through code practice and result analysis, this knowledge can be learned and applied more effectively.

The above is the detailed content of What are the underlying principles and lock upgrade process of synchronized in Java?. For more information, please follow other related articles on the PHP Chinese website!