Mastering Java Semaphore: How init, down, and up Ensure Thread Safety

Semaphore Model Overview

The semaphore is a synchronization primitive consisting of a counter and a waiting queue that are invisible to external code; they can only be accessed via three provided methods.

Three Core Methods

init() – Sets the initial value of the counter.

down() – Decrements the counter; if the result is less than 0, the calling thread is blocked.

up() – Increments the counter; if the result is ≤ 0, one thread is removed from the waiting queue and awakened. The condition uses >0 to indicate that no thread is blocked, so only ≤ 0 triggers a wake‑up.

Correct Usage Pattern

Call down() to acquire the semaphore (lock).

Perform the critical section work.

Call up() to release the semaphore.

If the semaphore is initialized to 1, a concurrent scenario should never see the counter > 0 unless up() is called prematurely, which defeats the purpose of a semaphore.

Atomic Guarantees

All three methods are atomic; the JDK implementation ( java.util.concurrent.Semaphore) guarantees this.

Java Code Example

In Java, acquire() and release() correspond to down() and up() respectively.

Consider two threads t1 and t2 calling acquire() on a semaphore with an initial count of 1: t1 succeeds, counter becomes 0, and proceeds. t2 sees the counter become -1 and is blocked.

When t1 finishes and calls release(), the counter goes from -1 to 0, satisfying the ≤ 0 condition, so t2 is awakened and can enter the critical section, guaranteeing mutual exclusion.

Why Not Just Use a Lock?

A lock provides mutual exclusion only. A semaphore can also limit the number of concurrent threads accessing a resource, making it suitable for resource pools such as database connection pools.

Implementing a Simple Rate Limiter

Set the semaphore counter to the number of resources N in the pool. Each thread calls down() before using a resource and up() after releasing it.

Note: The example uses Vector for the pool, which is not thread‑safe for add/remove operations; a proper concurrent collection should be used.