Understanding Java's AbstractQueuedSynchronizer (AQS): Core Components, Design, and Practical Applications

In Java concurrent programming, AbstractQueuedSynchronizer (AQS) is the core framework for building locks and synchronizers. It provides state management, FIFO thread queuing, and blocking/unblocking mechanisms to support efficient thread coordination tools.

1. Core Components of AQS

AQS consists of three core parts: state , a FIFO queue, and acquire/release methods. These work together to achieve efficient thread scheduling and resource management.

1. State (state)

AQS uses a volatile int state variable to represent the synchronizer's state, whose meaning is defined by concrete subclasses such as:

ReentrantLock : state indicates the lock re‑entrance count (0 means unlocked).

Semaphore : state indicates the number of remaining permits.

CountDownLatch : state indicates the remaining countdown; when it reaches 0 the latch triggers.

Thread‑safe Operations on state

Because state can be modified concurrently, AQS uses CAS (Compare‑and‑Swap) operations together with the volatile keyword to ensure atomicity.

CAS operation: compareAndSetState(int expect, int update) uses the Unsafe class to atomically update state .

Direct assignment: methods such as setState(int newState) rely on volatile for visibility across threads.

protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
protected final void setState(int newState) {
    state = newState;
}

2. FIFO Queue

AQS maintains a doubly‑linked waiting queue to manage threads that have not acquired the resource. The queue follows FIFO order to ensure fair competition.

Queue Structure and Thread Management

Head node (head) : the thread currently holding the resource.

Tail node (tail) : where new requesting threads are appended.

Node : each node stores a thread reference, status (e.g., waiting, cancelled), and forward/backward pointers.

When a thread cannot acquire the resource, it is wrapped in a Node and inserted at the tail, then blocked. Upon resource release, AQS unparks the next thread in the queue.

Thread Blocking and Unblocking

AQS uses LockSupport.park() to block a thread and LockSupport.unpark() to wake the next waiting thread, avoiding busy‑waiting and reducing CPU consumption.

3. Acquire/Release Methods

AQS defines abstract acquire and release methods that concrete subclasses implement. The logic relies on the current state and queue management.

Acquire (acquire)

The acquire process:

Check state to decide if the current thread may obtain the resource.

If insufficient, enqueue the thread as a Node and call park() to block.

After being unparked, retry until success or interruption.

Example from ReentrantLock.lock() :

public void lock() {
    sync.acquire(1);
}
protected final void acquire(int arg) {
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

Release (release)

The release process:

Update state according to the specific logic (e.g., decrement lock count).

Unpark the next waiting thread using unpark() .

Example from ReentrantLock.unlock() :

public void unlock() {
    sync.release(1);
}
protected final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

2. Design Philosophy and Advantages

1. Template Method Pattern

AQS extracts the common thread‑scheduling logic into a template, allowing subclasses to implement only tryAcquire and tryRelease , reducing code duplication.

2. Modularity and Extensibility

State management, queue operations, and business logic are decoupled, enabling developers to focus on resource acquisition/release rules without handling low‑level scheduling.

3. Performance and Fairness

AQS supports non‑fair (default) and fair locks; fair locks honor queue order, while non‑fair locks may allow barging, reducing context‑switch overhead.

3. Practical Use Cases

1. ReentrantLock Implementation

ReentrantLock uses AQS to implement a re‑entrant lock, checking state in tryAcquire and decrementing it in tryRelease .

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    } else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

2. Semaphore Implementation

Semaphore manages a permit count via AQS, decreasing state in acquire() and increasing it in release() .

public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

4. Common Questions and Extensions

1. Why does AQS use CAS instead of locks?

CAS provides a lock‑free atomic operation using hardware instructions (e.g., cmpxchg ), avoiding thread blocking and context‑switch overhead, which is advantageous in high‑concurrency scenarios, though it requires handling the ABA problem.

2. How does AQS handle thread interruption?

AQS marks the interrupt status via interrupt() and checks it during acquire ; if a waiting thread is interrupted, an InterruptedException may be thrown or the thread may handle it after releasing the resource.

3. How extensible is AQS?

Developers can subclass AbstractQueuedSynchronizer and implement tryAcquire and tryRelease to create custom synchronizers such as connection pools or task schedulers.

5. Summary

AQS is the cornerstone of Java concurrency, combining state management, FIFO queuing, and the template method pattern to abstract thread scheduling. Mastering AQS helps understand tools like ReentrantLock and Semaphore and equips developers to design efficient concurrent components.