bin zu blöd für threads - wait, notify, synchronized

[SpammerSlammer]

Liebe Leute,

ich habe mir schon ein paar Sachen über Threads (inkl. synchronized, wait und notify) durchgelesen und habe dann versucht, es an einem Minimalbeispiel nachzuvollziehen. Leider bin ich wohl zu blöd... ???:L Kann mir vielleicht jemand sagen, wie ich das folgende Code-Beispiel so abändern kann, dass thread2 von thread1 benachrichtigt wird, nachdem letzterer seine Nachricht ausgegeben hat? Zeitlich gesehen soll zuerst "thread2 - Teil 1", dann "thread1" und zuletzt "thread2 - Teil 2" ausgegeben werden. Übrigens weiß ich, dass hierfür eigentlich keine Threads gebraucht werden, aber es soll nur ein Minimalbeispiel sein, an dem ich es nachvollziehen möchte.

import java.io.*;

public class file2 {

    public file2() {
    
        thread2 t2 = new thread2();
        t2.start();
        
        thread1 t1 = new thread1();
        t1.start();
        
    }

    class thread1 extends Thread {

        public void run() {
            method1();
        }

        public synchronized void method1() {
            System.out.println("thread1");
            notify();            
        }

    }
    
    class thread2 extends Thread {

        public void run() {
            method2();
        }

        public synchronized void method2() {
            System.out.println("thread2 - Teil 1");
            try{
                wait();
            }
            catch (InterruptedException e) {
            }
            System.out.println("thread2 - Teil 2");
        }
        
    }
    
}

Und dabei kommt folgende Ausgabe raus:

thread2 - Teil 1
thread1

 

[Marco13]

wait und notify müssen sich auf's gleiche Objekt beziehen. Kannst den beiden Threads EIN gemeinsames objekt übergeben, und dann jeweils

synchonized (gemeinsamesObjekt) gemeinsamesObjekt.wait();
bzw.
synchonized (gemeinsamesObjekt) gemeinsamesObjekt.notify();

 

[SpammerSlammer]

Danke, so funktioniert es. :applaus:

Hier ist noch mal die vollständige Lösung - falls später mal jemand das gleiche Problem hat:

import java.io.*;

public class file2 {

    String test;

    public file2() {
        
        test = new String("test");
        
        thread2 t2 = new thread2();
        t2.start();
        
        thread1 t1 = new thread1();
        t1.start();
        
    }

    class thread1 extends Thread {
        
        public void run() {
            System.out.println("thread1");
            synchronized (test) {test.notify();}
        }

    }
    
    class thread2 extends Thread {
        
        public void run() {
            
            System.out.println("thread2 - Teil 1");
            try{
                synchronized (test) {test.wait();}
            }
            catch (InterruptedException e) {
            }
            System.out.println("thread2 - Teil 2");
        }

    }
    
}

 

[FArt]

Danke, so funktioniert es. :applaus:
Hier ist noch mal die vollständige Lösung - falls später mal jemand das gleiche Problem hat:

Hilft auch nichts. Schließliche hatten hier im Forum schon viele dieses Problem ...

 

[cyliax]

also ich hatte gerade gehofft, dass ich ne lösung für dieses allgegenwärtige notify und wait finde. aber leider funktioniert auch die vermeintlich letzte lösung bei mir nicht. woran kann das liegen... wenn man das ganz oft hintereinander ausführt ist es nämlich nicht sichergestellt, dass wirklich "thread2_teil1" dann "thread1" und dann "thread2_teil2" ausgeführt wird. Nur meistens, aber meistens reicht nicht.

kann da nochmal jemand drüber gucken? das mit dem synchronized objekt ist mir soweit klar, aber irgendwas haut datrotzdem nicht hin. vielen dank!

 

[Gast2]

es kann sein das erst thread1 startet er muss also vor seine ausgabe noch auf thread 2 warten und thread2 muss nach seiner 1. ausgabe ein notify senden...

 

[cyliax]

ähm, das da heißt?, irgendwo muss noch ein syncObject.wait hin und irgendwo ein syncObject.notify?

hier nochmal mein daraus abgeleitetes Beispiel:

	private void saveAndCompile() {
		
		SaveThread SaveThread = new SaveThread();
		SaveThread.start();

		CompilerThread compilerThread = new CompilerThread();
        	compilerThread.start();
        }

	class SaveThread extends Thread {
        public void run() {
            System.out.println("Dummy Speichern...");
            synchronized (syncObject) {syncObject.notify();}
        }
	}
    
    class CompilerThread extends Thread {
        public void run() {
            try{
                synchronized (syncObject) {syncObject.wait();}
            } catch (InterruptedException e) {}

            String cmd = "cmd /c compile.bat";
            try {
            	Runtime.getRuntime().exec(cmd);
            } catch (IOException e1) {}
        }
    }

Ich möchte halt gern sicherstellen, das erst gespeichert und dann compiliert wird... Danke vielmals!

 

[Empire Phoenix]

    class thread2 extends Thread {
        
        public void run() {
            System.out.println("thread2 - Teil 1");
            try{
                            thread1 t1 = new thread1();
            t1.start(); //Sollte die Probleme etwas minimieren
synchronized (test) {test.wait();}
            }
            catch (InterruptedException e) {
            }
            System.out.println("thread2 - Teil 2");
        }

    }

Zum Compilier dingesn:

das erst gespeichert und dann //Wenns hintereinander abläuft geben Threads nur begrenzt Sinn, du kannst schließlich auch beide teile hintereinander ausführen indem du dafür Funktionen nimmst. (Da ich annehme das es sich bloß um ein theoretisch Beispiel handelt is das in deisem fall ja auch egal)

 

[cyliax]

ah, danke... für unsere antworten hier bräuchten wir auch ein sync-Object

 

[tfa]

Vielleicht hilft dir ja Lock und Condition. Damit wird die ganze Sache meiner Meinung nach etwas einfacher als mit wait/notify.
http://www.java-forum.org/blogs/tfa/19-snippet-synchronisation-mit-locks-und-conditions.html

 

[cyliax]

danke euch allen, das mit notify und wait passt jetzt nach thread1-aufruf innerhalb von 2 erstmal soweit. wenns nicht hinhaut, dann gucke ich mir das snippet mit lock und condition nochmal genauer an.

 

[Empire Phoenix]

Dachte nen Praktische Beispiel kann auch nciht schaden ich poste mal eines:


Die Gameengine benutzt den Thread der start() aufruft für den GameLoop, somit muss dieses von einem Eigenen //
Thread aufgerufen werden (kurz die funktion returnt erst wenn das game beendet wird.)
Nun soll das Laden jedoch in einem eigenen Thread laufen (Animierter Ladescreen würde sonst ja nicht gehen )
Das Problem ich kann erst Laden, wenn der LWJGL krams läuft (sonst funktiniert Textureladen nicht, zb)
Somit übergebe ich ein syncro Object an die tiefen der Engine die notify() darauf ausführt, nachdem alles nötige Initialisiert wurde.

Warum so eine Konstruktion? (ein thread startet zwei weitere, ich könnte ja mit einem zusätzlichen auskommen.) Nun Das ganze wird durch einen Start Button ausgeführt, und Java findet es nicht wirklich lustig wenn ich den Swing/Awt/whatever thread mir zum Laden ausleihe. Zudem würde dann der Mainscreen (Login Config ect) erst beim beenden des Games/bzw nach dem Laden verschwinden.

final MassiveSpaceEngine game = new MassiveSpaceEngine();
					final Object syncro = new Object();
					
					Runnable loader = new Runnable(){
						@Override
						public void run() {
							synchronized(syncro){
								try {
									syncro.wait();
                                                                                                     game.InitLoading();
								} catch (InterruptedException e) {
									// TODO Auto-generated catch block
									e.printStackTrace();
								}
							}
							
						}
					};
					new Thread(loader).start();
					
					Runnable starter = new Runnable(){
						@Override
						public void run() {
							System.out.print("1");
							game.start(syncro);
						}
					};
					new Thread(starter).start();
					mainScreen.dispose();