Java main thread auf ergebnisse warten lassen...

NemesisFS · 2. Mai 2011

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 · 2. Mai 2011

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

Code:

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

NemesisFS · 2. Mai 2011

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:

Code:

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

Killkrog · 2. Mai 2011

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

Krik · 2. Mai 2011

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

Killkrog · 2. Mai 2011

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 · 2. Mai 2011

kannst du mir ein beispiel mit join zeigen?

Killkrog · 2. Mai 2011

Klar, hier:

Code:

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 · 2. Mai 2011

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 · 3. Mai 2011

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

Code:

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

Killkrog · 3. Mai 2011

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 · 3. Mai 2011

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 · 4. Mai 2011

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 · 4. Mai 2011

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 · 4. Mai 2011

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 · 4. Mai 2011

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

Suche

Java main thread auf ergebnisse warten lassen...

NemesisFS

Lt. Commander

F.b

Lieutenant

NemesisFS

Lt. Commander

Killkrog

Lt. Junior Grade

Krik

Fleet Admiral

Killkrog

Lt. Junior Grade

NemesisFS

Lt. Commander

Killkrog

Lt. Junior Grade

BullshitBingo

Gast

NemesisFS

Lt. Commander

Killkrog

Lt. Junior Grade

NemesisFS

Lt. Commander

Killkrog

Lt. Junior Grade

NemesisFS

Lt. Commander

Killkrog

Lt. Junior Grade

NullPointer

Lt. Commander

Ähnliche Themen