Classification and Explanation of Java Locks for Interview Preparation

This article introduces various classifications of locks commonly discussed in Java concurrency and interview contexts, aiming to provide concise definitions suitable for quick interview answers.

Fair lock / Unfair lock : A fair lock grants access to threads in the order they request it, while an unfair lock may allow later‑arriving threads to acquire the lock first, potentially causing priority inversion or starvation. In Java, ReentrantLock can be constructed as fair (default is unfair), and synchronized is inherently unfair.

Reentrant lock (also called recursive lock): The same thread can acquire the lock multiple times without deadlocking. Both ReentrantLock and synchronized are reentrant. Example:

synchronized void setA() throws Exception {
    Thread.sleep(1000);
    setB();
}

synchronized void setB() throws Exception {
    Thread.sleep(1000);
}

The above demonstrates that a thread holding the lock in setA can re‑enter the lock in setB, avoiding deadlock.

Exclusive lock / Shared lock : An exclusive lock can be held by only one thread at a time, whereas a shared lock can be held by multiple threads simultaneously. ReentrantLock is exclusive; ReadWriteLock provides a shared read lock and an exclusive write lock.

Mutex lock / Read‑Write lock : These are concrete implementations of the above concepts. In Java, ReentrantLock is a mutex lock, and ReadWriteLock implements read‑write locking.

Optimistic lock / Pessimistic lock : These describe strategies rather than concrete lock types. Pessimistic locking assumes conflicts and locks data preemptively; optimistic locking assumes conflicts are rare and uses techniques like CAS (compare‑and‑swap) to retry updates without locking.

Segment lock : Not a separate lock type but a design used in ConcurrentHashMap. The map is divided into segments, each protected by its own lock (a ReentrantLock), allowing concurrent updates to different segments while still providing thread safety.

Biased / Lightweight / Heavyweight lock : These are lock states used by the JVM for synchronized. A biased lock is fast when a single thread repeatedly acquires it; it upgrades to a lightweight lock when contention appears, and further upgrades to a heavyweight lock (causing thread blocking) if contention persists.

Spin lock : A lock where a thread repeatedly attempts to acquire the lock in a loop (spins) instead of blocking, reducing context‑switch overhead at the cost of CPU consumption. Typical implementations rely on CAS loops.

Source: cnblogs.com/lxmyhappy/p/7380073.html