Simulating a Traffic Signal Controller with Deadlock Prevention

Welcome to our lesson on simulating a traffic signal controller with deadlock prevention . In our previous lessons, you learned about the essentials of concurrency and how to handle concurrent operations safely. In this lesson, we will explore how to apply these concepts to real-world scenarios where multiple entities need controlled access to shared resources, particularly focusing on deadlock prevention in concurrent systems.

What You’ll Learn

By the end of this lesson, you will have a strong understanding of: How to simulate traffic control systems at intersections using Java . Utilizing synchronization in Java to manage concurrent access to shared resources. Implementing deadlock prevention techniques by controlling resource access with synchronized blocks. This lesson will guide you through creating a simulation of vehicles at an intersection, where efficient handling and coordination prevent deadlocks, ensuring smooth flow across different directions.

The Traffic Control Problem

Imagine a busy intersection where vehicles from different directions (North-South and East-West) need to pass through safely. Without any control, two vehicles coming from opposite directions could enter the intersection at the same time, potentially resulting in a collision or a traffic jam. Additionally, if both directions attempt to cross the intersection at the same time, they could block each other, leading to a deadlock, where neither vehicle can proceed. In the diagram above, you can see an intersection where vehicles travel in two directions: North-South and East-West . To control the traffic and prevent collisions or deadlocks, each direction has a corresponding lock, represented by the icons. In the code below, each lock controls one traffic stream: northSouthLock protects North-South traffic, and eastWestLock protects East-West traffic. This prevents vehicles using the same directional lock from crossing together, but it does not make the whole intersection mutually exclusive. If these directions physically conflict, use a single shared intersectionLock so only one vehicle can be in the intersection at a time.

Join the 1M+ learners on CodeSignal

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

Intersection Class

To demonstrate basic synchronization, we’ll define two separate locks for vehicles traveling North-South and East-West. Each vehicle must acquire the lock for its own direction before it can cross.

This means the example prevents simultaneous crossings within the same direction only. It does not prevent a North-South vehicle and an East-West vehicle from crossing at the same time. For a collision-safe single-intersection model, both methods should synchronize on the same intersectionLock.

Java

public class Intersection {
    private final Object northSouthLock = new Object();
    private final Object eastWestLock = new Object();

public class Intersection {
    private final Object northSouthLock = new Object();
    private final Object eastWestLock = new Object();

In the Intersection class, we declare two objects: northSouthLock and eastWestLock. These objects act as locks for controlling the flow of vehicles traveling in the North-South and East-West directions, respectively. The use of separate locks ensures that vehicles in different directions don't interfere with each other, allowing traffic to flow smoothly without conflict.

Java

    public void crossNorthSouth(String vehicle) throws InterruptedException {
        synchronized (northSouthLock) {
            System.out.println(vehicle + " is crossing North-South");
            Thread.sleep(100);
            System.out.println(vehicle + " has crossed North-South");
        }
    }

    public void crossNorthSouth(String vehicle) throws InterruptedException {
        synchronized (northSouthLock) {
            System.out.println(vehicle + " is crossing North-South");
            Thread.sleep(100);
            System.out.println(vehicle + " has crossed North-South");
        }
    }

The crossNorthSouth method is synchronized on northSouthLock, ensuring that only one vehicle can cross in the north-south direction at any given time. The Thread.sleep(100) simulates the time it takes for the vehicle to cross the intersection.

When the method is invoked, it acquires the northSouthLock, which guarantees that no other vehicle traveling North-South can enter the intersection until the current vehicle has crossed and released the lock. This is a critical step to ensure that only one vehicle crosses at a time in a specific direction, which helps prevent collisions.

Java

    public void crossEastWest(String vehicle) throws InterruptedException {
        synchronized (eastWestLock) {
            System.out.println(vehicle + " is crossing East-West");
            Thread.sleep(100);
            System.out.println(vehicle + " has crossed East-West");
        }
    }
}

    public void crossEastWest(String vehicle) throws InterruptedException {
        synchronized (eastWestLock) {
            System.out.println(vehicle + " is crossing East-West");
            Thread.sleep(100);
            System.out.println(vehicle + " has crossed East-West");
        }
    }
}

Similarly, the crossEastWest method uses eastWestLock to manage vehicles crossing east-west. Both methods ensure that crossing happens safely and without conflict, helping prevent any potential deadlocks.

The logic in crossEastWest mirrors that of crossNorthSouth, but uses the eastWestLock. This approach isolates the two directions, so a vehicle crossing North-South does not interfere with one crossing East-West. The separate locks mean that there is no waiting between directions, helping to prevent the classic deadlock scenario where threads (or, in this case, vehicles) are waiting on each other to release a lock.

Running the Traffic Signal Controller

The Main class simulates the intersection by creating threads that represent vehicles traveling in different directions.

Java

public class Main {
    public static void main(String[] args) {
        Intersection intersection = new Intersection();

public class Main {
    public static void main(String[] args) {
        Intersection intersection = new Intersection();

We first create an Intersection object, which controls the flow of traffic through the intersection.

Java

        // Create the northBound thread
        Thread northBound = new Thread(() -> {
            try {
                while (true) {
                    intersection.crossNorthSouth("Car North");
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // Create the northBound thread
        Thread northBound = new Thread(() -> {
            try {
                while (true) {
                    intersection.crossNorthSouth("Car North");
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

The northBound thread simulates vehicles crossing from north to south. It continuously calls the crossNorthSouth method, simulating vehicles crossing one by one with a brief pause between crossings (Thread.sleep(200)).

Java

        // Create the eastBound thread
        Thread eastBound = new Thread(() -> {
            try {
                while (true) {
                    intersection.crossEastWest("Car East");
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // Create the eastBound thread
        Thread eastBound = new Thread(() -> {
            try {
                while (true) {
                    intersection.crossEastWest("Car East");
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

Similarly, the eastBound thread simulates vehicles crossing from east to west. Both threads run concurrently, representing real-time traffic flow through the intersection.

Java

        // Start both threads
        northBound.start();
        eastBound.start();
    }
}

        // Start both threads
        northBound.start();
        eastBound.start();
    }
}

The start() method begins the traffic simulation. Both directions of traffic run in parallel, and vehicles continue to cross until the program is interrupted manually.

This simplified version runs indefinitely, continuously simulating cars crossing the intersection without any interruptions or manual stop.