In multithreaded programs, it’s often necessary to control access to resources or synchronize thread execution. Semaphore and Barrier are high-level synchronization mechanisms that help address these challenges.

Today, we’ll explore each of these mechanisms in sequence and understand their differences. Let’s begin with Semaphore.

Semaphore in Java are implemented through the java.util.concurrent.Semaphore class.

Constructors

Semaphore(int permits): Constructor that creates a semaphore with a certain number of permissions. The permissions represent the number of accesses to the shared resource.

Semaphore(int permits, boolean fair): Сonstructor that provides first-come, first-served resolution.

If fair is set to true, the semaphore will grant permissions in first-in-first-out (FIFO) order, which can help avoid starvation. Default - false.

Main Methods

The acquire() method requests a single permission. If a permission is available, it’s granted immediately; otherwise, the thread is blocked until a permission becomes available. Once a task is completed, the release() method is used to release the permission, returning it to the semaphore. If other threads were waiting for a permission, one of them will be unblocked.

Imagine a parking lot with a limited number of spaces. The semaphore functions as a controller, keeping track of the available spaces and denying access once the lot is full.

You can also find out how many permissions are currently available in Semaphore using the int availablePermits() method. You can also try to get a permission using the boolean tryAcquire() method, returns true if a permission was obtained and false if not.

Outcomes

In other words, a Semaphore is useful when you need to provide limited simultaneous access to a specific code segment. The only drawback is the potential for a deadlock if threads are blocked in the wrong order.

Now, let’s move on to the next synchronization mechanism that is even simpler to use but will be 100 percent valuable for your needs.

CyclicBarrier

Barrier in Java are represented by the java.util.concurrent.CyclicBarrier class. The main methods of CyclicBarrier include:

Constructors CyclicBarrier

CyclicBarrier(int parties): Constructor that creates a barrier that blocks threads until a certain number of threads (parties) arrive.

CyclicBarrier(int parties, Runnable barrierAction): Constructor that creates a barrier with a given number of parties and an action (barrierAction) that is executed when all parties arrive at the barrier.

Methods CyclicBarrier

The main method await() which is used as a barrier and does not let the thread go any further until all threads reach this method. Returns a sequence number indicating the order of arrival of the participants.

It may happen that not all threads will reach the barrier and the program will hang, for this purpose int await(long timeout, TimeUnit unit) method is used, which is similar to await(), but with timeout. If the timeout expires before all participants arrive, the method generates a TimeoutException exception.

You can also find out the number of participants required to complete the barrier int getParties() and its similar method int getNumberWaiting() which returns the number of participants currently waiting at the barrier.

It is also possible to check if the barrier has been destroyed if one of the threads is interrupted or the waiting timeout has expired using the boolean isBroken() method. If it has been broken, you can use the void reset() method which will simply restore the barrier.

Note

It should be taken into account that some flow may not reach the barrier because of an error or something else and then it is clear that the barrier will not allow those flows that are currently waiting at the barrier