Looking for an Appropriate synchronization java code for this problem

Problem

Riders come to a bus stop and wait for a bus. When the bus arrives, all the waiting riders invoke boardBus, but anyone who arrives while the bus is boarding has to wait for the next bus. The capacity of the bus is 50 people; if there
are more than 50 people waiting, some will have to wait for the next bus. When all the waiting riders have boarded, the bus can invoke depart. If the bus arrives when there are no riders, it should depart immediately. Note that busses and riders will continue to arrive throughout the day. Assume inter-arrival time of busses and riders are exponentially distributed with a mean of 20 min and 30 sec, respectively.

For this problem, I need a concurrent program which can satisfy mutual exclusion and synchronization in java with clear explanation. Can anyone help me?

The Bus

public class Bus {

    public Bus() {
    }

    public void depart() {
        System.out.println("I am departuring from the busstand....");
    }
}

The Rider

import java.util.ArrayList;
import java.util.concurrent.Semaphore;

public class Rider{

    public void invokeBoard() {
        System.out.println("I am boarding to the .... in the bus");
    }
}

The Bus stand Manager

import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class BusStandManager {
    boolean isArrived;
    int n;
    Semaphore count_mutex;
    Semaphore bus_mutex;
    ArrayList<Rider> waiting_stage_queue;
    ArrayList<Rider> bus_stand_queue;

    public BusStandManager() {

        this.isArrived = false;
        this.n = 0;
        this.count_mutex = new Semaphore(1);
        this.bus_mutex = new Semaphore(1);
        this.waiting_stage_queue = new ArrayList<>();
        this.bus_stand_queue = new ArrayList<>();
    }

    public void putRider() {
        Rider rider = new Rider();
        try {
            count_mutex.acquire();
            if (n < 50 && !isArrived) {
                n = n + 1;
                bus_stand_queue.add(rider);
            } else {
                waiting_stage_queue.add(rider);
            }
            count_mutex.release();
        } catch (InterruptedException e) {
            System.out.println("Thread is suspended");
        }
    }

    public void load_bus()  {
        try{
        bus_mutex.acquire();
        Bus bus = new Bus();
        isArrived = true;
        if (n != 0) {
            for (Rider rider : bus_stand_queue) {
                rider.invokeBoard();
            }
            n = 0;
        }
        bus.depart();}
        catch (InterruptedException ie){
            System.out.println("Thread is suspended");

        }
    }

    public void execute() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // method reference introduced in Java 8
        executorService.submit(this::putRider);
        executorService.submit(this::load_bus);

        // close executorService
        executorService.shutdown();
    }
}

The Usage

public class Main {

    public static void main(String[] args) {
        BusStandManager busStandManager = new BusStandManager();
        busStandManager.execute();
    }
}

Thread is not running as I expect the output is

This problem is a common problem in concurrent programming. Grant Hutchins did a fantastic solution to this problem.
He used 3 semaphores and a counter to get a solution

waiting = 0;
mutex = new Semaphore(1)
bus = new Semaphore(0)
boarded = new Semaphore(0)

waiting - number of riders in the boarding area.

mutex - this is used to protect the waiting variable.

bus - It is used to tell the riders that the bus in the court or not.

boarded - It is used to tell the bus that rider is boarded.

The bus process code

mutex . wait ()
n = min ( waiting , 50)
for i in range ( n ):
bus . signal ()
boarded . wait ()
waiting = max ( waiting -50 , 0)
mutex . signal ()
depart ()

Here, the mutex is used to lock the waiting variable since whenever the bus arrives no one can increment waiting.
n is minumum of waiting and 50 since if we have 70 riders we can only 50 riders to the bus and if we have 30 riders we can take all riders to the bus. With this minimum condition, we take only 50 riders to the bus.
Then for each rider bus signal that it's arrived so the rider can get into the bus.

After 50 riders are boarded in the bus, waiting will be set to zero if we have riders less than 50 in the initial stage otherwise we decrement 50 from riders since 50 riders are boarded.

then we release the mutex so the new rider can come and increase the value.

Rider code

mutex . wait ()
waiting += 1
mutex . signal ()
bus . wait ()
board ()
boarded . signal ()

rider thread waits for the mutex when it gets the lock it will increase waiting to tell that it is waiting for the bus.

The rider thread is waiting for the bus so when the bus arrives bus rider thread can go to the board method. then the rider executes the board() method it will signal that rider is boarded. so the bus will signal again to board another thread.

We have another solution as well It is desribed in this book.
Java implementation can be found in this github link

`