TrafficController.java

/**
 * TrafficController.java — single-lane bridge monitor.
 *
 * THREAD-SAFETY SUMMARY:
 * - SYNCHRONIZED METHODS TURN THIS CLASS INTO A MONITOR SO ONLY ONE CAR THREAD
 *   CAN ENTER OR LEAVE AT A TIME WHILE MUTATING COUNTS.
 * - wait()/notifyAll() PARK THREADS WHEN THE OPPOSITE COLOR IS ON THE BRIDGE
 *   AND WAKE THEM WHEN THE BRIDGE IS EMPTY, PREVENTING BUSY-WAITING.
 * - redCarsOnBridge / blueCarsOnBridge TRACK OCCUPANCY UNDER THE SAME LOCK
 *   SO MUTUAL EXCLUSION IS ENFORCED EXACTLY ONCE.
 */
public class TrafficController {

    // Number of red cars currently on the bridge
    private int redCarsOnBridge = 0;
    // Number of blue cars currently on the bridge
    private int blueCarsOnBridge = 0;

    /**
     * ENTERLEFT IS SYNCHRONIZED SO ONLY ONE RED CAR THREAD CAN CHECK/MODIFY
     * THE COUNTS AT A TIME, AND IT WAITS UNTIL BLUE CARS HAVE LEFT.
     */
    public synchronized void enterLeft() {
        // KEEP WAITING WHILE BLUE CARS ARE STILL CROSSING
        while (blueCarsOnBridge > 0) {
            try {
                // WAIT RELEASES THE MONITOR LOCK SO BLUE CARS CAN CALL leaveLeft()
                wait();
            } catch (InterruptedException e) {
                System.err.println("Red car thread interrupted");
            }
        }
        // SAFE TO ENTER; UPDATE RED COUNT WHILE HOLDING THE LOCK
        redCarsOnBridge++;
    }

    /**
     * ENTERRIGHT MIRRORS ENTERLEFT FOR BLUE CARS USING THE SAME MONITOR LOCK
     * AND wait()/notifyAll() PROTOCOL.
     */
    public synchronized void enterRight() {
        // KEEP WAITING WHILE RED CARS ARE STILL CROSSING
        while (redCarsOnBridge > 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                System.err.println("Blue car thread interrupted");
            }
        }
        // SAFE TO ENTER; UPDATE BLUE COUNT ATOMICALLY
        blueCarsOnBridge++;
    }

    /**
     * LEAVELEFT IS SYNCHRONIZED SO ONLY ONE THREAD DECREMENTS THE BLUE COUNT
     * AND IT CALLS notifyAll() WHEN THE BRIDGE BECOMES EMPTY TO WAKE RED CARS.
     */
    public synchronized void leaveLeft() {
        blueCarsOnBridge--;

        if (blueCarsOnBridge == 0) {
            notifyAll(); // SIGNAL THREADS BLOCKING IN ENTERLEFT/ENTERRIGHT
        }
    }

    /**
     * LEAVERIGHT DOES THE SAME FOR RED CARS, BROADCASTING WHEN THE BRIDGE CLEARS.
     */
    public synchronized void leaveRight() {
        redCarsOnBridge--;

        if (redCarsOnBridge == 0) {
            notifyAll(); // WAKE ANY BLUE CARS WAITING TO ENTER
        }
    }
}