Why Use Unfair Locks? Java Implementation and Performance Benefits

What Is an Unfair Lock?

An unfair lock allows a thread to acquire the lock immediately without following a first‑in‑first‑out order, so new threads can "cut in line" and take the lock directly.

Why Use an Unfair Lock?

Fair locks often reduce overall throughput because every lock acquisition incurs queue management overhead; an unfair lock reduces this overhead and can increase system throughput.

Implementation Example

Below is a simple Java example using ReentrantLock with the fairness flag set to false to create an unfair lock.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UnfairLockDemo {
    private final Lock lock = new ReentrantLock(false); // unfair lock

    public void method() {
        lock.lock();
        try {
            // thread work
        } finally {
            lock.unlock(); // release without queue handling
        }
    }
}

ReentrantLock

is unfair by default; setting the constructor argument to false means lock acquisition does not follow FIFO, allowing newer threads to obtain the lock before older waiting threads.

How It Works Internally

Lock acquisition uses the tryAcquire method to check if the lock can be obtained immediately; if so, the thread gets the lock at once.

If the lock is not available, the thread is parked and placed into a wait queue.

Threads in the queue may be awakened and retry acquisition, but the order is not strictly FIFO.

When to Choose an Unfair Lock

If strict fairness is not required and higher throughput is desired, an unfair lock can reduce context switches and scheduling overhead.

Typical Use Cases

Cache systems – avoiding queue delays improves response time.

Database connection pools – reduces wait time for connections, increasing overall throughput.

High‑concurrency computation – lowers thread‑switching latency and boosts performance.

In scenarios with high contention where throughput matters more than strict ordering, an unfair lock is often the better choice.