Salve sto cercando di fare un elaborato sulla sincronizzazione.
E' il classico caso della strada con un ponte a senso unico.Sono riuscito a portarlo a termine solo dopo mi è stato detto di apportare una modifica ovvero creare due liste d'attesa in modo da risvegliare i thread o da una parte o dall'altra del ponte.
Allora ho creato invece di una classe Car ,due classi una per senso di marcia e ho provato a fare una sincronizzazione a blocchi.Solo che mi da questo errore

Exception in thread "Thread-1" java.lang.IllegalMonitorStateException: current thread not owner  at java.lang.Object.notifyAll(Native Method)

è tutto il pomeriggio che smanetto.Sono alle prime armi quindi offendetemi pure:P
vi posto il codice della classe Bridge quella che contiene i blocchi sincronizzati

import java.util.Vector;

public class Bridge{
    private Vector macchinedx;
    private Vector macchinesx;
    private boolean comingleft;
    private boolean comingright;
    private int countDx;
    private int countSx;
  
    public Bridge(Vector macchineDestra, Vector macchineSinistra){
      
        comingleft=false;
        comingright=false;
        macchinedx = macchineDestra;
        macchinesx = macchineSinistra;
        countDx=0;
        countSx=0;
      
    }
  
    public void rightpass(){
      
        synchronized(macchinedx){
        System.out.println(" --------Passa l'auto " +((DxCar)macchinedx.firstElement()).getCarId()+ " di destra");
        System.out.println("Dimensione vettore destra :" +macchinedx.size());
      
      
        while(comingleft==true ){
            try{
                macchinedx.wait();
            }      
          
            catch(InterruptedException e){System.out.println("Wait di destra");}
        }
      
        comingright=true;
      
      
        macchinedx.remove(0);
        countDx++;
        if(countDx==3){
            countDx=0;
            comingright=false;
            macchinesx.notify() ;}
      
        else{
            if(macchinedx.isEmpty()){
                countDx=0;
                comingright=false;
                macchinesx.notify();}
            else
                macchinedx.notify();}
    }}
  
    public void leftpass(){
        synchronized(macchinesx){
        System.out.println(" --------Passa l'auto " +((SxCar)macchinesx.firstElement()).getCarId()+ " di sinistra");
        System.out.println("Dimensione vettore sinistra :" +macchinesx.size());
          
      
        while(comingright==true){
            try{
                macchinesx.wait();
            }      
          
            catch(InterruptedException e){System.out.println("Wait di sinistra");}
        }
      
        comingleft=true;
      
      
        macchinesx.remove(0);
        countSx++;
        if(countSx==3){
            countSx=0;
            comingleft=false;
            macchinedx.notify();}
      
        else{
            if(macchinesx.isEmpty()){
                countSx=0;
                macchinedx.notify());}
            else
                macchinesx.notify();}
    }
  
}}

questa è la classe macchina di destra quella di sinistra è identica solo con Sx invece di Dx

public class DxCar extends Thread{
          
        private int DxId;
        private int direzione;
        private Bridge Ponte;
      
        public DxCar(int DxId,int direzione,Bridge Ponte){
      
    
        this.DxId=DxId;          
        this.Ponte=Ponte;
        this.direzione=direzione;
     
        }
      
        public int getCarId(){
          
            return DxId;
        }
     
        public void run(){
    
            Ponte.rightpass();
    
}}

infine la classe principale

import java.util.Vector;

public class Elaborato1{
private static int DxId;
private static int SxId;
public static void main(String[] args){
          
             int direzione;
          
          
            Vector macchinedx = new Vector (10);
          
            Vector macchinesx = new Vector (10);
          
            Bridge Ponte = new Bridge(macchinedx,macchinesx);
          
            DxId=0;
            SxId=0;
            for (int c = 0 ; c <20; c++){
                        direzione=(int) ((Math.random()*10)%2);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {}
              
                //System.out.println("Passaggio :" " + DxId + SxId ", macchina proveninete da "+ (direzione==1 ? "destra" : "sinistra"));
                if(direzione==1){
                    DxId++;
                    if (!macchinedx.add(new DxCar(DxId,direzione,Ponte)))
                        System.out.println("Creazione macchina destra fallita!");
                    ((Thread) (macchinedx.lastElement())).start();}
                else{
                    SxId=SxId+1;
                    if(!macchinesx.add(new SxCar(SxId,direzione,Ponte)))
                        System.out.println("Creazione macchina sinstra fallita!");
                    ((Thread) (macchinesx.lastElement())).start();
                    }
           }System.exit(1);
     }
}

Se ci dici l'errore completo (ovvero a che riga di codice si genera) magari possiamo essere un p' più di aiuto. L'unica cosa che mi viene in mente è questa: dato che l'eccezione che si verifica succede quando un processo viene messo in sleep o in wait e non potrebbe esserlo (classico: non è sincronizzato su un oggetto che funge da "controllore") l'errore potrebbe essere nella classe Elaborato1 (riga in grassetto):

 

DxId=0;
            SxId=0;
            for (int c = 0 ; c <20; c++){
                        direzione=(int) ((Math.random()*10)%2);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {}

 

Come vedi lo sleep è fatto senza che il metodo si sincronizzi su qualcosa. Va bene anche se stessi (il this).

Prova a sostituire:

 try {

    Thread.sleep(1000);
 } catch (InterruptedException e) {}

 

con:

 syncronized(this){

        try {

            Thread.sleep(1000);
        } catch (InterruptedException e) {}

}