Verzweiflung wegen Berechnung mit Multithreading

[kilopack15]

Hallo Leute,
ich habe ein Problem mit Threads. Ja ich weiß viel Text, aber das Problem ist sicher trivial. Habe euch unten meine ProblemKlasse angehangen, die ich verständlich kommentiert habe. Hier schildere ich euch meine AUfgabe und mein Problem.

Meine Aufgabe: Ich soll die Werte einer bestimmten Matrix berechnen. Dazu soll ich mir 4 Threads zur Hilfe holen, die sich jeweils immer um die Berechnung eines bestimmten Viertels der Matrix kümmern. Dafür stehen die Methoden obenrechts(), obenlinks(), untenrechts(), untenlinks().

Das ganze soll folgendermaßen ablaufen: jeder Thread rechnet sein Viertel aus. In einem der Threads (Hauptthread) werden dann die Ergebnisse zusammengefügt und es wird entschieden ob die Ergebnisse hinreichend genau sind. Wenn ja, wird abgebrochen, wenn nein müssen die Threads durch die Anweisung matrix.nextIteration(); nochmal ihre jeweiligen Methoden berechnen.
Falls einer der Threads etwas langsamer ist, müssen die anderen derweil auf ihn warten. Das habe ich dann mit wait() und notify() gemacht.

Ich habe dazu eine Klasse geschrieben, die aber nicht funktioniert. Es wird eine IllegalMonitorStateException geworfen. Was habe ich mit den Threads falsch gemacht? Bin mir sicher dass ich zb eine Methode falsch angewendet habe. Könnt ihr mir bitte helfen?
Hier meine bisherige, falsche Lösung:

         //Erstellen der Threads
        Hauptthread tol = new Hauptthread();   
        ThreadOR tor = new ThreadOR();   
        ThreadUR tur = new ThreadUR();   
        ThreadUL tul = new ThreadUL();   

        class Hauptthread extends Thread{

            public synchronized void run(){
                while(abbruch==false){  //Während das Abbruchkriterum nicht erfüllt ist...
                obenlinks();        //Thread berechnet seinen Teil der Matrix
               
                /*Hier soll der Thread dreimal auf die Ergebnisse 
                der drei anderen Threads warten. Jeder der anderen Threads 
                benachrichtigt nämlich diesen Hauptthread hier, nachdem er seine Methode                             berechnet hat
                 * */
                
                try {    
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if(Abbruchkriterium == true){ //dann wird abgebrochen
                    abbruch = true;
                    tor.interrupt();   //Threads werden nicht mehr gebraucht
                    tol.interrupt();
                    tur.interrupt();
                    tul.interrupt();
                   
                }else{   //Falls nicht abgebrochen werden soll
                    matrix.nextIteration();  //refreshen der Matrix
                    notifyAll();  //die anderen Threads werden geweckt und sollen nochmal rechnen
                }
                }
            }   
        }
          
       
        class ThreadOR extends Thread{
                public synchronized void run(){
                    while(true){
                    obenrechts();
                    tol.notify();        //Der Hauptthhread (oben) wird benachrichtigt, sobald                                                            ThreadOR mit seiner Methode fertig ist
                    try {
                        wait();   //Thread wartet, ob er weitermachen soll (erfüllt wenn im                                                         Hauptthread notifyALL() erreicht wird
                    } catch (InterruptedException e1) {
                        e1.printStackTrace();
                    }
                    }
            }
        }
       
        class ThreadUR extends Thread{
             //gleich aufgebaut wie ThreadUL
        }
       
       
        class ThreadUL extends Thread{
              //gleich aufgebaut wie ThreadUL
        }

        public void solve() { //Methode startet Threads
            tol.start(); //Starten der Threads
            tor.start();
            tur.start();
            tul.start();
            try { 
                tol.join();  //warten bis der Hauptthread fertig ist
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
       

       
    }

 

[thecain]

http://docs.oracle.com/javase/tutorial/essential/concurrency/index.html

Ist mal ein grosser Tipp.