Use of CyclicBarrier in java concurrency

Introduction

CyclicBarrier is a thread-safe component introduced in java 5. It has the concept of a barrier, which is used to wait for all threads to finish executing before performing a specific operation.

If we have many threads and each thread computes some data, then we need to wait for all the threads to finish executing and then add up the data computed by each thread to the final result, then we can use CyclicBarrier.

Methods of CyclicBarrier

Let’s look at the constructor of CyclicBarrier.

    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

        public CyclicBarrier(int parties) {
        this(parties, null);
    }

CyclicBarrier has two constructors, the first accepts only one parameter, indicating the number of threads that need to act in unison. The second parameter is called barrierAction, indicating that the departure barrier is the method that needs to be executed.

One of the barrierAction is a Runnable, in which we can define the last work to be executed.

Look again at the important await method.

    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }

        public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException {
        return dowait(true, unit.toNanos(timeout));
    }

Await also has two methods, one with a time parameter and one without a time parameter, it essentially calls the lock.newCondition().await() method, We consider two cases below.

The thread is not the last thread to call await

In this case, the thread will enter the wait state until the following condition is sent.

The last thread called await()
Another thread interrupts the current thread
The other thread interrupts the other thread that is waiting
Other threads time out while waiting for the barrier
reset() method called by other thread on that barrier

If the thread has set the interrupted state when calling await(), or is interrupted while waiting, then an InterruptedException will be thrown and the interrupted state will be cleared. (This is consistent with Thread’s interrupt() method)

If any thread is in the wait state, the barrier is reset at that time. Or if the barrier is broken while the thread is calling the await method or is waiting, then a BrokenBarrierException will be thrown.

If any thread is interrupted while waiting, then all other waiting threads will throw a BrokenBarrierException and the barrier will be set to the broken state.

If the thread is the last one to call the await method

In this case, if the barrierAction is not empty, then the thread will call the barrierAction before the other threads continue execution.

If the action throws an exception, then the state of the barrier will be set to broken.

Take a look at the reset() method.

    public void reset() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            breakBarrier(); // break the current generation
            nextGeneration(); // start a new generation
        } finally {
            lock.unlock();
        }
    }

This method will set the barrier to the broken state and open a new generation for the next round of operations.