JVM Lock Optimization, Escape Analysis, and Synchronization Elimination

The author, a senior architect, introduces JVM lock optimization techniques that enhance code execution efficiency in multithreaded environments.

1. Lock Optimization

1.1 Spin Lock and Adaptive Spin – Modern multi‑core CPUs can keep a waiting thread on the processor by spinning for a short timeout. The JVM enables this with the +XX:UseSpinning flag (enabled by default since JDK 1.6) and allows the spin count to be adjusted via -XX:PreBlockSping (default 10).

1.2 Lock Elimination – The JIT compiler can remove locks when escape analysis proves that synchronized code cannot be accessed by other threads. For example, concatenating three strings:

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

Javac optimizes this to use StringBuilder internally, and because the builder does not escape the method, the synchronization can be eliminated.

Another version showing the explicit use of StringBuilder :

public String concatStr(String x, String y, String z) {
    StringBuilder sb = new StringBuilder();
    sb.append(x);
    sb.append(y);
    sb.append(z);
    return sb.toString();
}

1.3 Lock Coarsening – When a series of synchronized operations on the same object occur consecutively (e.g., multiple append calls on a StringBuffer ), the JVM may merge them into a single larger critical section to reduce lock‑unlock overhead:

StringBuffer buffer = new StringBuffer();
/** lock coarsening */
public void append() {
    buffer.append("aaa").append(" bbb").append(" ccc");
}

2. Escape Analysis

Escape analysis determines whether an object can be accessed outside its defining method or thread. If it cannot, the JVM can apply several optimizations:

Stack allocation – objects that never escape are allocated on the stack, reducing GC pressure.

Scalar replacement – parts of an object are kept in CPU registers instead of memory.

Synchronization elimination – objects accessed by a single thread need no locking.

The analysis distinguishes between method escape (object passed to another method) and thread escape (object stored in a field accessed by other threads).

References

https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html

https://www.cnblogs.com/xidongyu/p/10891303.html

https://www.cnblogs.com/kkkkkk/p/5543799.html