Dostęp wielu wątków do jednej metody

Cześć, na wstępie napiszę, że szukałem podobnego tematu, ale nic się nie przydało.

Mam do napisania program, gdzie pasażerowie przechodzą przez most na statek. Most ma pewną przepustowość K, a statek pojemność N > K. Statek odpływa co godzinę, a kapitan musi dopilnować, żeby w tym czasie nie było na moście wchodzącego
pasażera. Oczywiście na moście nie może być więcej osób niż K, a na statku więcej niż N.

Mam następujący problem: powołuję co losowy czas nowe wątki Pasażera, które podczas wchodzenia na most opuszczają semafory Mostu i Statku, ale czasami pojawia się problem, że wszystkie naraz wchodzą na most, przekraczając tym samym pojemność Statku i blokując program...
Niestety słabo jeszcze rozumiem tą współbieżność.

////////////////////////////Metoda run() klasy Pasażer
public synchronized void run() {
		try {
			while(!passed){ //warunek czy pasażer już przeszedł przez most
				if (s.isOpened()){   //sprawdzam czy statek jest w porcie
					if (s.getPermits() > 0){ //sprawdzam czy na statku są jeszcze wolne miejsca
						synchronized (l){   //wg mnie w tej sekcji jest problem
							b.acquireSemaphore();
							s.acquireSemaphore();
						}
						
						TimeUnit.MILLISECONDS.sleep(rand.nextInt(4000));
						b.releaseSemaphore();						
						passed = true;
					}
					else{
						TimeUnit.SECONDS.sleep(1);
						System.out.println("Pasażer " + passengerID
								+ " czeka na kolejną turę, brak miejsc.");
					}
				}else{
					TimeUnit.SECONDS.sleep(1);
					System.out.println("Pasażer " + passengerID
							+ " czeka na przybycie statku");
				}
			}
		} catch (InterruptedException e) { e.printStackTrace(); }
	}

        //////////////////////////////////////KLASA STATEK
	private static Semaphore shipSemaphore;
	private static ReentrantLock shipLock = new ReentrantLock();

	public synchronized void acquireSemaphore() throws InterruptedException{ Ship.shipSemaphore.acquireUninterruptibly(); }

	public synchronized void releaseSemaphore(){ Ship.shipSemaphore.release(); }

	public synchronized void lock(){
		try {
			Ship.shipLock.lockInterruptibly();
		} catch (InterruptedException e) { System.out.println("Nie mozna wykonac: Bridge.bridgeLock.lockInterruptibly()");}
	}

//////////////////////////////////////KLASA MOST

	private static Semaphore bridgeSemaphore;

	public synchronized void acquireSemaphore() throws InterruptedException { Bridge.bridgeSemaphore.acquireUninterruptibly(); }

	public void releaseSemaphore(){ Bridge.bridgeSemaphore.release(); }

To co napisałeś nie ma sensu. Robisz klasyczny błąd "check-then-act", czyli najpierw coś sprawdzasz a potem wykonujesz akcje ale nie masz pewności czy w międzyczasie stan nie uległ zmianie. twoje isOpened oraz getPermits mają być semaforami właśnie!
Semafor może mieć swój własny licznik. Wtedy posażer robi acquire() i jeśli licznik spadł już do 0 (bo N pasażerów dostało pozwolenie na przechodzenie) to pasażer będzie czekał. Nowy przypływający statek podniesie znów semafor do poziomu N i tak w kółko.

Widzę tutaj arcy dziką(pochodzisz z Bieszczad?) próbę zrobienia swojego lock'a.

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/Lock.html

Metodę run() Pasażera przerobiłem na razie tak:

 public synchronized void run() {
		try {
			while(!passed){
				if(s.isOpened()){    /////// 1*
			   	    s.acquireSemaphore();
				    b.acquireSemaphore();
				    TimeUnit.MILLISECONDS.sleep(rand.nextInt(4000));
				    b.releaseSemaphore();
				    passed = true;
			}else{
					TimeUnit.SECONDS.sleep(1);
					System.out.println("Pasażer " + passengerID
							+ " czeka na przybycie statku");
				}}} catch (InterruptedException e) { e.printStackTrace(); }}

Klasę sprawdzającą Kapitan tak:

	public void run(){
		try{
			while(true){
				if(System.currentTimeMillis() - startTime > 20000){   ////3*
					s.lock();
					if(b.getPermits() == b.getCapacity()){
						TimeUnit.SECONDS.sleep(5);
						s.freeSemaphore();
						startTime = System.currentTimeMillis();
						s.unlock();   //////////////////////////////////// 2*
					}else{
						System.out.println("Czekam na pasażerów... Jeszcze " + (b.getCapacity() - b.getPermits()) + " pasażerów.");
						TimeUnit.SECONDS.sleep(1);
					}}}} catch (InterruptedException e) {}
	}

W chwili obecnej działa mi prawie, bo w punkcie 2* niestety nie dochodzi do odblokowania statku, nie mam pojęcia czemu. Jeszcze tylko nie wiem jak dokładnie zastąpić punkt 1*, chciałem zrobić 2 semafory binarne, np. przyBrzegu i naMorzu i zaimplementować mniej więcej taką zasadę działania: Pasażer zamyka przyBrzegu, ludzie wchodzą, otwiera naMorzu, statek zamyka naMorzu, wypływa przypływa, otwiera przyBrzegu, ale przeszkadza mi w tym punkt 3*. Nie mam pomysłu jak dodać w punkcie 1 taki semafor, który byłby kontrolowany przez proces Kapitana.

I co tu niby przerobiłeś? To nadal jest po prostu źle.

while(!passed){
                if(s.isOpened()){    /////// 1*
                       s.acquireSemaphore();
                    b.acquireSemaphore();

Ten kod jest błędny i tyle. Powinieneś mieć tu tylko jeden semafor który pozwala wejść na most kiedy statek czeka. Koniec, kropka. Nic więcej. Kiedy zbliża sie koniec czasu statek robi acquire na wszystkim co pozostało w semaforze (więc automatycznie blokuje wszystkich pasażerów którzy nie zdażyli wejść na most) i odpływa. Nowy statek przypływa i robi release semafora z wartością k.

Nie musisz tu żadnych cudów na kiju robić i sprawdzać czy statek czeka. Semafor robi to za ciebie! Jak zawołasz acquire a statek nie czeka to wątek się zablokuje aż się nie pojawi statek i nie podbije semafora.

Nie probuj na sile zapewnic synchronizacji w konkretnej metodzie klasy Pasazer. Tego typu klasy powinny byc normalnymi klasami bez synchronizacji metod. Klasami typu Thread powinny byc inne klasy, ktore wykorzystuja te klasy do wykonania pewnych dzialan. Synchronizacja natomiast moze byc najprosciej zapewniona przez monitor, ktory posiada metody synchronizowane przy wykonywaniu konkretnej akcji, np. przejdz przez most. To jest moj stary kod, gdzie robilem podobne zadanie.

https://www.dropbox.com/sh/f1k605p9h4q6p5x/AAAhEVO1PmenU5xgWSC9KqWMa?dl=0

Ok, teraz mniej więcej rozumiem jak to ma działać, dzięki @Shalom, usunąłem w pasażerze wszystkie* if()*, zostawiłem tylko te 2 semafory ilościowe dla mostu i statku, a metodę *lock() * zamieniłem tak, żeby opuszczała semafor statku do końca, tylko, że teraz po całkowity zwolnieniu semafora mostu statek nie odpływa... Metoda run() Kapitana została taka sama, tylko usunąłem to freeSemaphore().