JVM Lock Optimization: Spin Locks, Lock Elimination, Lock Coarsening, and Escape Analysis

JVM employs various lock optimizations such as spin locks, adaptive spinning, lock elimination, and lock coarsening to improve execution efficiency.

Spin locks let a waiting thread keep the CPU busy for a short timeout; they can be enabled with +XX:UseSpinning and tuned via -XX:PreBlockSping.

Lock elimination relies on escape analysis to remove synchronization when the JVM proves that an object does not escape the current thread or method, as illustrated by the string concatenation example where

public String concatStr(String x, String y, String z) { return x + y + z; }

is compiled to use StringBuilder without synchronization.

Lock coarsening merges consecutive synchronized operations on the same object into a single larger critical section; the example shows a StringBuffer being appended multiple times within one synchronized block:

StringBuffer buffer = new StringBuffer();
/** 锁粗化 */
public void append(){
    buffer.append("aaa").append(" bbb").append(" ccc");
}

Escape analysis determines whether objects escape a method or thread, enabling optimizations such as stack allocation, scalar replacement, and synchronization elimination, which reduce heap pressure and synchronization overhead.