dieses Thema scheint schon öfter vorgekommen zu sein, aber die Antworten im Archiv konnten mich nicht so ganz zufrieden stellen. Ich habe eine Anwendung, die ich gerne parallelisiert ablaufen lassen möchte (eine Art Breiten-/Tiefensuche in einem Baum). Die Datenstrukturen sind soweit Thread-safe. Ich will folgendermassen vorgehen:
Ich habe eine Hauptklasse (einen Master), der einen einzigen Suchthread startet. Dieser macht dann einen Schritt Breitensuche, behält sich einen Pfad der Breitensuche und startet mit den restlichen Pfaden neue Threads, die aber gleichberechtigt zu diesem Thread sein sollen. Wenn auf diese Weise eine bestimmte Anzahl Threads entstanden sind, dann soll mit Tiefensuche im Baum weitergesucht werden (d.h. keine neuen Threads). Jetzt kommts: Sobald einer dieser Thread bei seiner Suche einen Treffer landet, dann soll er das dem Master signalisieren (synchronized) und dieser stoppt anschliessend alles, was noch am Laufen ist (ausser sich selbst). Ich habe mir das so vorgestellt: Der Master erzeugt eine ThreadGroup und setzt die ThreadGroup, in der er selbst steckt als ParentGroup ein. Alle weiteren Threads werden dann in diese ThreadGroup zugeordnet. Soweit die Beschreibung, gibt’s da irgendwelche Denkfehler?
Die Realisierung habe ich mir so vorgestellt, dass die Klasse, die als Thread gestartet wird nicht identisch mit der Hauptklasse ist, und das Interface Runnable implementiert (also keine Unterklasse von Thread). Welche Methoden brauche ich da zusätzlich noch? Ich weiss, dass ich run() benötige, aber wie stoppe ich diesen Thread wieder (Deadlocks sind aufgrund der gewählten Datenstruktur ausgeschlossen)? Brauche ich da weitere Methoden? Die Methode destroy scheint es ja gar nicht zu geben…
Ich hab jetzt nicht alles so auf die Schnelle nachvollziehen können, aber wenn es dir eigentlich darum geht Threads wieder anzuhalten, dann lies dir mal folgendes Dokument durch:
ein thread läßt sich meiner Meinung nach schlecht von draußen beenden. Da es aber selbst beendet, wenn die run() Methode durchgelaufen ist, habe ich ein boolean-variable eingesetzt:
ein thread läßt sich meiner Meinung nach schlecht von draußen
beenden. Da es aber selbst beendet, wenn die run() Methode
durchgelaufen ist, habe ich ein boolean-variable eingesetzt:
Du hast Recht. Da ich aber nicht warten kann, bis die run Methode am Ende ist, habe ich mir was anderes überlegt. Die Klasse, die alle Threads verwaltet, setzt ein Variable, die diesen Threads signalisiert, ob diese noch weitermachen sollen oder nicht. Der Grund dafür ist einfach, denn alle diese Threads stecken in einer Suchmethode (Tiefensuche) fest, die sie erst dann beenden können, wenn diese eine Lösung gefunden haben oder wenn sie den ganzen Teilbaum durchsucht haben.
Das sieht dann ungefähr so aus:
public void run()
{
if ( breitensuche )
{
// Starte in der Breitensuche zusätzliche Threads
breitensuche();
}
else
{
tiefensuche();
}
}
public breitensuche()
{
while ( Main.weitermachen() )
{
//...
}
}
public tiefensuche()
{
while ( Main.weitermachen() )
{
//...
}
}
in der Hauptklasse (Main):
private boolean cont = false;
// Falls status== true, dann wurde ein Treffer erzielt
public synchronized void receiver( boolean status )
{
if (status == true )
{
cont = true;
}
else
{
//... (Uninteressant)
}
}
public boolean weitermachen()
{
return cont;
}
Die Variable cont wird dann gesetzt, wenn ein Thread einen Treffer in seinem Suchbaum erzielt. Ich habe mir dabei überlegt, dass es nicht sehr effizient ist die Methode weitermachen als synchronized zu implementieren, denn dann wäre das ein ziemliches Nadelöhr. Es ist aber kein Problem, wenn die einzelnen Threads ein bisschen über das Ziel hinausschiessen und noch ein wenig weitersuchen, bis alle Threads sich beendet haben.