Traffic Signal Simulation Using CyclicBarrier

Traffic Signal Simulation with CyclicBarrier

Welcome back! In the last lesson, we learned how to manage resource allocation in a restaurant ordering system using semaphores. In this lesson, we’re going to apply similar synchronization principles using CyclicBarrier to simulate a traffic signal system . This lesson will deepen your understanding of task synchronization by coordinating the actions of multiple threads that depend on each other.

What You'll Learn

In this lesson, we’ll explore: How to use CyclicBarrier to coordinate the behavior of multiple threads. Implementing a traffic signal system at a four-way intersection. How to manage thread execution with ExecutorService and cyclic synchronization. By the end of this lesson, you’ll know how to apply CyclicBarrier in real-world scenarios like traffic management, where tasks need to synchronize before proceeding.

Recap: CyclicBarrier and Its Role in Synchronization

You’ve encountered various concurrency tools in previous lessons, such as semaphores for managing limited resources. CyclicBarrier is different—it’s a synchronization aid that makes multiple threads wait for each other before continuing their tasks. This is especially useful when actions must be synchronized, like cars waiting for a green light at an intersection. In this lesson, we’ll use CyclicBarrier to simulate a traffic signal system. Cars from different directions (threads) arrive at the intersection and must wait for each other before they can proceed. The barrier makes sure that no car proceeds until all have arrived at the intersection, just like how traffic lights coordinate cars at a busy junction.

Setting Up the Traffic Signal System

We begin by defining the core structure for the traffic signal simulation. This includes setting up the CyclicBarrier and managing threads using ExecutorService . Java import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TrafficSignalSimulation {private final CyclicBarrier barrier; private final ExecutorService executor; private final int totalCycles; public TrafficSignalSimulation(int numDirections, int totalCycles) {this.barrier = new CyclicBarrier(numDirections, this::changeTrafficLights); this.executor = Executors.newFixedThreadPool(numDirections); this.totalCycles = totalCycles;}} In this snippet: CyclicBarrier : This is initialized with the number of directions (cars) needing synchronization. It waits for all cars to arrive at the intersection before allowing any of them to proceed. ExecutorService : Manages the threads representing cars arriving from different directions. Each car (thread) moves independently, but is synchronized using the barrier. totalCycles : This determines how many times the cars will go through the intersection before the simulation ends. Java this.barrier = new CyclicBarrier(numDirections, this::changeTrafficLights); Here, once all threads reach the barrier, the changeTrafficLights method is executed. This action simulates the event of traffic lights changing to allow cars to proceed through the intersection. With this setup, we have the basic structure to simulate a traffic signal system where cars wait for each other at the intersection.

Join the 1M+ learners on CodeSignal

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

Simulating Car Movement

Next, we simulate the movement of cars through the intersection, making them wait for others using the CyclicBarrier.

Java

public void simulate(int direction) {
    executor.submit(new Car(direction, barrier, totalCycles));
}

private static class Car implements Runnable {
    private final int direction;
    private final CyclicBarrier barrier;
    private final int totalCycles;

    public Car(int direction, CyclicBarrier barrier, int totalCycles) {
        this.direction = direction;
        this.barrier = barrier;
        this.totalCycles = totalCycles;
    }

    @Override
    public void run() {
        String threadName = "Car-" + direction;
        for (int cycle = 1; cycle <= totalCycles; cycle++) {
            try {
                System.out.println(threadName + " arrives at the intersection (Cycle " + cycle + ").");
                barrier.await(); // Cars wait at the red light
                System.out.println(threadName + " proceeds through the intersection (Cycle " + cycle + ").");
                Thread.sleep((long) (Math.random() * 1000 + 500)); // Simulate crossing time
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println(threadName + " was interrupted.");
                break;
            } catch (BrokenBarrierException e) {
                System.err.println(threadName + " encountered a broken barrier.");
                break;
            }
        }
        System.out.println(threadName + " has completed all cycles.");
    }
}

public void simulate(int direction) {
    executor.submit(new Car(direction, barrier, totalCycles));
}

private static class Car implements Runnable {
    private final int direction;
    private final CyclicBarrier barrier;
    private final int totalCycles;

    public Car(int direction, CyclicBarrier barrier, int totalCycles) {
        this.direction = direction;
        this.barrier = barrier;
        this.totalCycles = totalCycles;
    }

    @Override
    public void run() {
        String threadName = "Car-" + direction;
        for (int cycle = 1; cycle <= totalCycles; cycle++) {
            try {
                System.out.println(threadName + " arrives at the intersection (Cycle " + cycle + ").");
                barrier.await(); // Cars wait at the red light
                System.out.println(threadName + " proceeds through the intersection (Cycle " + cycle + ").");
                Thread.sleep((long) (Math.random() * 1000 + 500)); // Simulate crossing time
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println(threadName + " was interrupted.");
                break;
            } catch (BrokenBarrierException e) {
                System.err.println(threadName + " encountered a broken barrier.");
                break;
            }
        }
        System.out.println(threadName + " has completed all cycles.");
    }
}

In this block, we simulate car movement at an intersection using the Car class, which implements Runnable. Each car is modeled as a separate thread.

simulate(int direction): Initializes the simulation for a car from a specific direction, submitting it as a task to the ExecutorService to run in a separate thread.
Car Class:
- Fields:
  - direction: Identifies the car's arriving direction.
  - barrier: The CyclicBarrier instance used for synchronization among car threads.
  - totalCycles: The number of simulation cycles for each car at the intersection.
- run() Method:
  - Cycle Loop: The car announces its arrival for each cycle.
  - barrier.await(): The car waits synchronously with others. The barrier ensures all cars wait before proceeding, akin to a red light.
  - Thread.sleep(): Simulates the time taken to cross the intersection, introducing a pause.
  - Exception Handling:
    - InterruptedException: Handles thread interruptions by setting the interrupt status and breaking the loop.
    - BrokenBarrierException: Indicates a disrupted barrier; prints an error and exits the loop.
  - Completion Message: Prints a message when the car finishes all cycles.

This block uses CyclicBarrier for synchronized starts, ensuring all cars proceed together, similar to traffic light operations at intersections. This structure ensures that no car proceeds through the intersection until all have arrived, mimicking real-life traffic lights.

Now, let’s define the action that happens when all cars have arrived at the intersection and the barrier breaks—changing the traffic lights.

Java

private void changeTrafficLights() {
    System.out.println("\n=== Traffic lights have changed. Cars can now proceed. ===\n");
}

private void changeTrafficLights() {
    System.out.println("\n=== Traffic lights have changed. Cars can now proceed. ===\n");
}

This method is automatically invoked when the barrier is broken (i.e., when all cars are ready to proceed). It mimics the changing of traffic lights, signaling that it’s safe for the cars to continue.

Finally, after all the cars have completed their cycles, we need to shut down the simulation properly.

Java

public void shutdown() {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(totalCycles * 10, TimeUnit.SECONDS)) {
            executor.shutdownNow();
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                System.err.println("Executor did not terminate.");
            }
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
    System.out.println("Traffic signal simulation ended.");
}

public void shutdown() {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(totalCycles * 10, TimeUnit.SECONDS)) {
            executor.shutdownNow();
            if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                System.err.println("Executor did not terminate.");
            }
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
    System.out.println("Traffic signal simulation ended.");
}

executor.shutdown(): Ensures that all running tasks (car threads) finish before shutting down the system.
awaitTermination(): Waits for all threads to complete. If they don’t finish in the allotted time, the executor is forcefully terminated.

This ensures that the simulation doesn't terminate prematurely, and all threads complete their tasks safely.

Simulating a traffic signal system using CyclicBarrier helps you understand task synchronization, which is crucial in many real-world systems. Here’s why this concept is important:

Synchronizing Tasks: The barrier ensures that tasks proceed together, preventing any task from getting ahead before the others are ready.
Real-world Application: This mirrors real-world traffic management systems, where coordination is essential to avoid collisions and ensure safety.
Concurrency Control: With CyclicBarrier, you can manage tasks that must operate in lockstep, making it useful for scenarios like simulations, parallel computing, or even multiplayer games.

Now that you’ve seen how CyclicBarrier is used to synchronize tasks in a traffic simulation, let's move to the practice section and apply these concepts. You’ll have the chance to reinforce your understanding with similar synchronization challenges!

Traffic Signal Simulation with CyclicBarrier

What You'll Learn

Recap: CyclicBarrier and Its Role in Synchronization

Setting Up the Traffic Signal System

Join the 1M+ learners on CodeSignal

Simulating Car Movement

Changing the Traffic Lights

Shutting Down the Simulation

Why It Matters