Java main thread auf ergebnisse warten lassen...

[NemesisFS]

Hi,
ich versuche grade eine Aufgabe an n prozesse zu verteilen, die ihre ergebnisse dann in ein array schreiben. Danach soll mit diesem Array weitergearbeitet werden. Nun bin ich leicht verwirrt was die ganzen methoden wait, notify, join etc. angeht und komme nicht so ganz auf den trichter wie ich sowas implementieren sollte... kann mir wer einen wink geben? =)

gruß nemesis

 

[F.b]

wie wärs mit ner while-schleife, bei der abgefragt wird ob die Threads noch "am Leben" sind:

while(t1.isAlive() || t2.isAlive()...) {
 try {
  Thread.sleep(10);
 }
 catch(Exception e) {}
}

 

[NemesisFS]

habe ich mir auch schon überlegt, wurde dann aber doch zu komplex, weil ich mit nem thread array arbeite, die anzahl der threads ist variabel.

ich hab ne alternative, wo die threads aus nem threadpool kommen. gibt es ne abfrage für den threadpool, ob der noch beschäftigt ist?

EDIT: Troll ich... problem gelöst:

        executor.shutdown();
        while(!executor.isTerminated()) {
            try {
                Thread.currentThread().sleep(1);
            }
            catch(InterruptedException e) {}
        }

 

[Killkrog]

Schau dir mal die Methode "join()" von Thread an...

 

[Krik]

Alternativ kannst du auch per PipedInputStream und PipedOutputStream eine Signalleitung erstellen, über die zwei Threads kommunizieren können.

 

[Killkrog]

Wie auch immer, man sollte IMMER while-Schleifen mit sleeps vermeiden, um auf Threads zu warten. Das ist so ein schlimmer Overhead, dass alles zuende ist... Wie dabei die Piped Streams helfen sollen, ist mir noch nicht klar. Die Ansteuerung ist ja kein Problem für ihn, nur das Pausieren...

Wie gesagt, join() oder Monitore benutzen!

 

[NemesisFS]

kannst du mir ein beispiel mit join zeigen?

 

[Killkrog]

Klar, hier:

public class JoinExample {

	private static class SmartThread extends Thread {

		private Thread t;

		public SmartThread(Thread threadToWaitFor) {
			t = threadToWaitFor;
			start();
		}

		public void run() {
			System.out.println("SmartThread wurde gestartet!");

			System.out.println("SmartThread wartet auf die Terminierung vom im Paramter übergebenen Thread!");
			try {
				t.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			System.out.println("SmartThread wurde beendet!");
		}

	}

	public static void main(String[] args) throws Exception {
		Thread t = new Thread() {

			public void run() {
				System.out.println("Hilfs-Thread gestartet. Wird 5 Sekunden lang etwas arbeiten!");
				try {
					sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			};
		};
		
		new SmartThread(t);
		
		t.start();
	}
}

 

[BullshitBingo]

Das Problem ist ja gar nicht mal der Overhead! Wenn man innerhalb einer While-Schleife ständig eine Bedingung überprüft oder sleep ausführt macht man nichts anderes als aktives Warten und das ist absolute Grütze. Das führt unweigerlich zu Race Conditions und kann auch Priority Inversion ermöglichen!

Wenn man mit Threads programmiert, sollte man sich unbedingt mit Interprozess-Kommunikation befassen!

 

[NemesisFS]

funktioniert das ganze auch mit schleifen?
folgendes tuts bei mir nämlich nicht:

try {
    for(Thread t : threads) {
        t.join();
    }
}
catch(InterruptedException e) {}

 

[Killkrog]

Di solltest dir eventuell mal die Dokumentation derjenigen Methoden durchlesen, die du versuchst zu benutzen...

t.join()

bedeutet, dass derjenige Thread, der diese Methode ausführt (sozusagen der gerade aktive), wartet, bis der Thread t stirbt. Es ist klar, dass deine Schleife im ersten Element stecken bleibt...

 

[NemesisFS]

genau darauf soll die schleife doch warten: dass alle threads des arrays durchgelaufen sind. habe inzwischen das problem gelöst, es lag nicht an der schleife, es hatte sich ein fehler beim erstellen der threads eingeschlichen.

 

[Killkrog]

Dein Thread t0 springt in die Schleife.
Du nimmst das erste Elemente der Schleife, sagen wir das ist der Thread t1, und lässt t0 solange schlafen, bis t1 terminiert. Erst dann und nur dann wird t0 das zweite Elemente t2 der Schleife bearbeiten können und wird wiederum solange eingeschläfert, bis t2 terminiert.

 

[NemesisFS]

ja, das ist doch genau das, was ich will, es läuft erst weiter, sobald alle threads beendet sind. wenn jetzt t1 länger als der rest braucht, sind die restlichen schleifendurchläufe sehr schnell zu ende sein, oder?

 

[Killkrog]

okay, diese handhabung setzt aber vorraus, das bereits alle Threads, auf die gewartet werden soll, existieren und gestartet sein müssen. Wenn das bei dir der Fall ist, sollte es funktionieren.

 

[NullPointer]

Versuch's doch mal mit einem ThreadPoolExecutor. Mir scheint, der könnte dein Problem vereinfachen.