Coordinating Threads with CyclicBarrier

Welcome back to our advanced journey into concurrency! In the previous lesson, we explored semaphores to manage access to shared resources. Today, we will build on that foundation by learning how to coordinate threads using CyclicBarrier . This tool helps synchronize threads so they meet at a common point before proceeding, which is crucial in complex multithreaded applications.

What You'll Learn

In this lesson, you will discover: The concept and use cases of CyclicBarrier . How to synchronize threads at a common barrier point. Setting up parties along with barrier actions. By the end, you'll be able to manage thread coordination efficiently, ensuring that groups of threads reach designated synchronization points before continuing their tasks.

What are CyclicBarriers

A CyclicBarrier is a synchronization aid that allows a set of threads to wait for each other to reach a common barrier point. It's particularly useful in programs involving a fixed group of threads that need to coordinate at certain stages of execution. The barrier is called "cyclic" because it can be reused after the threads waiting at the barrier have been released. For example, you might use a CyclicBarrier in situations where a set of tasks must all reach a certain point before any can proceed. After all the threads arrive at the barrier, they are released together, and the barrier can be reused if needed. Key Features include: Barrier Point Synchronization : Threads call the await() method to signal they've reached the barrier point, and they block until all threads reach the barrier. Reusability : Once all threads reach the barrier, it resets, allowing it to be reused for multiple cycles. Optional Barrier Action : A task can be executed when all threads have reached the barrier. This is often used for tasks that depend on the collective progress of all threads, such as combining results or setting up the next stage of computation. CyclicBarriers are ideal in scenarios like simulations, where phases of tasks must be coordinated, or in games, where multiple players or entities must wait for each other at certain points before progressing.

Example: Hikers Reaching a Summit

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Implementing the Hiker Class (Hiking Logic)

Next, let’s implement the core logic for the Hiker class. Each hiker will hike to the base camp, hike to the summit (where they will wait for all other hikers), and then hike back down.

Java

import java.util.concurrent.BrokenBarrierException;

@Override
public void run() {
    try {
        // Hike to Base Camp (no waiting at this point)
        hike("Base Camp");

        // Hike to Summit (wait at the summit for all hikers)
        hike("Summit");
        barrier.await(); // Wait at the summit for all other hikers to arrive

        // Continue the journey after all have arrived at the summit
        hike("Back to Base Camp");

        System.out.println(Thread.currentThread().getName() + " has completed the hike.");

    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
}

private void hike(String destination) throws InterruptedException {
    System.out.println(Thread.currentThread().getName() + " is hiking to " + destination + ".");
    Thread.sleep((long) (Math.random() * 3000) + 1000); // Simulate hiking time
    System.out.println(Thread.currentThread().getName() + " has arrived at " + destination + ".");
}

import java.util.concurrent.BrokenBarrierException;

@Override
public void run() {
    try {
        // Hike to Base Camp (no waiting at this point)
        hike("Base Camp");

        // Hike to Summit (wait at the summit for all hikers)
        hike("Summit");
        barrier.await(); // Wait at the summit for all other hikers to arrive

        // Continue the journey after all have arrived at the summit
        hike("Back to Base Camp");

        System.out.println(Thread.currentThread().getName() + " has completed the hike.");

    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
}

private void hike(String destination) throws InterruptedException {
    System.out.println(Thread.currentThread().getName() + " is hiking to " + destination + ".");
    Thread.sleep((long) (Math.random() * 3000) + 1000); // Simulate hiking time
    System.out.println(Thread.currentThread().getName() + " has arrived at " + destination + ".");
}

Let's break down what the above code does:

Hiking Process: The hike() method simulates the process of hiking by printing a message and then pausing the thread for a random period (using Thread.sleep()) to represent travel time. Each thread has its own pace, so the sleep duration varies.
Barrier Synchronization: After hiking to the summit, each hiker calls barrier.await(). This causes the thread to pause and wait until all other hikers have also called await(). Once all threads reach this point, the barrier opens, and they can continue hiking.
Exception Handling: The run() method includes handling for InterruptedException and BrokenBarrierException to ensure the application handles interruptions and issues with the barrier properly.

This structure models how hikers pause and wait for each other before continuing. It ensures that no one proceeds until all hikers have reached the summit.

Setting Up the Main Class

Now, let's set up the Main class to simulate a group of hikers reaching the summit. The CyclicBarrier will make sure all hikers wait for each other at the summit before proceeding.

Java

import java.util.concurrent.CyclicBarrier;

public class Main {
    public static void main(String[] args) {
        final int NUM_HIKERS = 5; // Number of hikers

        // Create a CyclicBarrier with a barrier action
        CyclicBarrier barrier = new CyclicBarrier(NUM_HIKERS, new Runnable() {
            @Override
            public void run() {
                // This task executes once all hikers reach the summit
                System.out.println("\nAll hikers have reached the summit! Let's take a group photo!\n");
            }
        });

        // Create and start hiker threads
        for (int i = 1; i <= NUM_HIKERS; i++) {
            new Thread(new Hiker(barrier), "Hiker " + i).start();
        }
    }
}

import java.util.concurrent.CyclicBarrier;

public class Main {
    public static void main(String[] args) {
        final int NUM_HIKERS = 5; // Number of hikers

        // Create a CyclicBarrier with a barrier action
        CyclicBarrier barrier = new CyclicBarrier(NUM_HIKERS, new Runnable() {
            @Override
            public void run() {
                // This task executes once all hikers reach the summit
                System.out.println("\nAll hikers have reached the summit! Let's take a group photo!\n");
            }
        });

        // Create and start hiker threads
        for (int i = 1; i <= NUM_HIKERS; i++) {
            new Thread(new Hiker(barrier), "Hiker " + i).start();
        }
    }
}

Here's what we're doing in the Main class:

Creating the CyclicBarrier: We initialize a CyclicBarrier with 5 hikers. The second parameter is a barrier action that runs when all hikers reach the summit. In this case, it prints a message indicating that everyone has reached the summit, and they can now take a group photo.
Starting Threads: We loop over the number of hikers, creating a new thread for each one using the Hiker class. Each thread starts immediately after creation, simulating the hikers’ journeys to the summit. The barrier ensures that no hiker can complete the journey without waiting for all other hikers to arrive at the same point.

This class brings together all the threads and coordinates their progress using the CyclicBarrier.