[robo47]

Ich wollte eigentlich nur wissen ob es ausreichend und sauber ist einfach das Programm am ende mit System.exit(0); zu beenden oder ob man sich in irgendeiner Form um selbst gestartete, eventuell noch laufende Threads kümmern sollte.

Nur um kurz anzureisen um was es geht, mein aktuelles Programm initialisiert ein JFace ApplicationWindow, in der Dispatch-Loop wird beim ersten Durchlauf dann ein Thread (Refresher) gestartet der mehrere andere Threads startet.

Diese Threads wiederum sind Oberservables die als Observer den View (das JFace ApplicationWindow) haben und im Hintergrund den Zustand (erreichbar / nicht erreichbar) von etwas rausfinden sollen (Socketverbindungen zu verschiedenen Ports auf verschiedenen IPs) und in der update-Methode des Views wird dann via asyncExec ein Runnable gestartet, der die passenden Änderungen am View vornimmt.

Im Refresher läuft wiederum eine while(true) - Schleife i so dass die Threads zur Überprüfung der Erreichbarkeit nach einer gewissen Zeit [ mittels sleep(30000) ], wieder gestartet werden um wieder zu schauen ob der Zustand sich verändert hat.


Aktuell habe ich noch bedenken, dass via System.exit(0); die Threads unter Umständen in einer falschen Reihenfolge gestoppt werden könnten und so z.b. einer der Threads versucht auf den View zuzugreifen obwohl dessen Shell/Display schon disposed wurde oder der Thread in dem er läuft schon gestoppt wurde.

Muss ich mir da sorgen machen ? Oder gibt es beim beenden durch System.exit() vielleicht eine zuverlässige Reihenfolge wie alle Threads und Objekte vernichtet werden.

Vielleicht hat ja jemand auch noch empfehlenswerte Online-Lektüre für einen JAVA-Einsteiger zum Thema nebenläufige Programmierung / Threads und Co.

mfg
robo47

[mepeisen]

Bei System.exit(0) wird relativ abrupt alles gestoppt. Die Threads werden dann "zeitgleich" aufhören zu arbeiten. Soweit zumindest meine Erfahrung und das dürfte auch irgendwo stehen.

Ob Objekte "sichtbar" zerstört werden, also finalize aufgerufen wird, ist dann nicht mehr garantiert. Der Garbage-Collector ruft in der Regel finalize auf und der kommt nach System.exit(0) gar nicht mehr zum Zug.


Gängiger Weg ist es, sich die Threads zu merken und sie in der richtigen Reihenfolge zu beenden, bevor man die Anwendung sauber beendet. Dazu beispielsweise im Main-Loop des Threads auf ein Flag prüfen (das Flag sollte volatile sein), ob der Thread beendet werden soll und entsprechende Schlaf-Perioden so weit zu minimieren, dass der Thread nicht einfach nur minutenlang pennt, sondern alle 500ms oder so dieses Flag abprüft.

[robo47]

Okay, das werde ich mal versuchen umzusetzen.

Danke

[rath]

Hallo,
ich würde mir einen Thread-Pool schreiben und an der JVM
einen Shutdown-Hook anhängen, also einen Thread welcher
vor dem Beenden der JVM ausgeführt wird, und dieser beendet
dann unter Verwendung des Thread-Pools deine Threads in gewünschter
Reihenfolge.
http://www.dpunkt.de/java/Programmie...ogramms/9.html
Viele Grüße
Ralf