🚦 Traffic Light Concurrency Problem

Problem Statement:
Simulate a traffic intersection where:

• Multiple roads (threads) lead to a single intersection (shared resource).

• Only one direction of traffic can pass at a time (mutual exclusion).

• Traffic lights (semaphores/locks) control access to avoid accidents (race conditions).

• Bonus: Add turn lanes, pedestrian crossings, or emergency vehicle priority.

💡 Possible Solutions & Approaches

1. Basic Version (4-Way Intersection)

   

   At a busy four-way intersection, there's no traffic light, but a smart controller is in charge. Each road — North, South, East, and West — has a gatekeeper (a semaphore) that starts locked (red light 🚫).

   The controller runs forever in a loop:

   1. It opens the North and South gates (green light 🟢) and lets one car from each direction pass.

   2. After 5 seconds, it closes those gates (red light again 🔴).

   3. Then it opens the East and West gates for 5 seconds and lets a car from each direction pass.

   4. Repeat forever…

🚗 Meanwhile, from each direction, cars keep arriving — but they stop at the gate and wait (using acquire()) until the controller lets them go.

Once the light turns green (via release()), a car goes through, thanks the controller, and may or may not leave the gate open for the next car (depending on whether the car calls release() again).

This way, order and safety are maintained at the intersection using semaphores — and no crashes happen!

import java.util.concurrent.Semaphore;

public class TrafficLightBasic {
    // Semaphores for each direction (initially 0 = RED)
    private static Semaphore north = new Semaphore(0);
    private static Semaphore south = new Semaphore(0);
    private static Semaphore east = new Semaphore(0);
    private static Semaphore west = new Semaphore(0);

    public static void main(String[] args) {
        // Traffic light controller thread
        Thread controller = new Thread(() -> {
            while (true) {
                try {
                    System.out.println("\n🟢 NORTH/SOUTH GREEN");
                    north.release(); // Green for North
                    south.release(); // Green for South
                    Thread.sleep(5000); // 5 sec green light
                    north.acquire(); // Back to red
                    south.acquire();

                    System.out.println("\n🟢 EAST/WEST GREEN");
                    east.release();
                    west.release();
                    Thread.sleep(5000);
                    east.acquire();
                    west.acquire();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        controller.setDaemon(true);
        controller.start();

        // Simulate cars arriving from different directions
        new Thread(() -> car(north, "North Car")).start();
        new Thread(() -> car(south, "South Car")).start();
        new Thread(() -> car(east, "East Car")).start();
        new Thread(() -> car(west, "West Car")).start();
    }

    private static void car(Semaphore sem, String name) {
        while (true) {
            try {
                sem.acquire(); // Wait for green light
                System.out.println(name + " is passing through!");
                Thread.sleep(1000); // Time to cross intersection
                sem.release(); // Not strictly needed if controller handles it
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

More Solution will be discussed in our course.