Thread beenden und warten, bis er fertig ist

[Rock Lobster]

Servus,

habe ein kleines Problem mit Threads. Und zwar will ich einen Thread starten, dann später irgendwann abbrechen und im Main-Thread aber solange warten, bis er tatsächlich fertig ist.

Mein erster Ansatz war folgendermaßen:

public class Test extends Thread
{
    public boolean finished;
    public boolean running;
        
    public void run()
    {
        running = true;
        finished = false;
        
        while(running)
        {
            // blablabla
            // ...
        }
        
        finished = true;
    }
    
    public void cancel()
    {
        running = false;
        
        while(! finished);
    }
}

Leider mußte ich dann feststellen, daß ein Aufruf der Methode "cancel" vom Main-Thread aus irgendwie nicht im Main-Thread ausgeführt wird - zumindest wird finished niemals auf true gesetzt, weil die while-Schleife in der cancel-Methode für immer blockiert.

Ein nächster Versuch war, statt "extends Thread" ein "implements Runnable" draus zu machen, und dies dann einem separaten Thread-Konstruktor zu übergeben. Aber auch da lief es haargenau gleich ab.

Mein dritter Versuch war nun, direkt im Main-Thread zu warten, also die cancel-Methode des Test-Threads wurde auf ein einfaches "running = false" reduziert, und im Main-Thread kam die folgende Methode dazu:

public void cancelAndWait(Test t)
{
    t.cancel();
    
    while(! t.finished);
}

Aber auch diese Schleife blockierte (egal, wie lang man gewartet hat, habe auch mal Konsolenausgaben eingefügt um das besser kontrollieren zu können), und das verstehe ich absolut nicht. Der Main-Thread läuft doch parallel zum Test-Thread ab?! Da kann doch die eine Methode niemals den anderen Thread blockieren...

Also wie gesagt, das geht über meine Vorstellungskraft hinaus. Daher meine Fragen: 1) Woran liegt das, daß die Methode dennoch blockiert, und 2) Was gibt es für eine bessere / richtige Möglichkeit für das Problem?

 

[Rock Lobster]

Habe gerade das kleine Beispiel oben kompiliert bzw. ein kleines Programm drumrumgebaut und da funktioniert es tadellos...

Allerdings ist das richtige Programm ja auch etwas komplexer, trotzdem ist das eigentliche Gerüst exakt dasselbe...

 

[JPKI]

Schon mal Thread#join() probiert?

Kleines Beispiel:

public static void main(String args[]) {
Thread t = new MyThread();
t.start();
try { t.join(); } catch (InterruptedException ex) { ex.printStackTrace(); } //Hier wartet er so lange, bis der t-Thread fertig ist
}

 

[Alu]

Vermutlich wurde cancel ausgeführt bevor der Thread vom System "angefasst" wurde.
Daher wurde running in run() wieder auf true gesetzt und weder cancel() noch run() kamen zum Ende.
Ich hab die Initalisierung von running geändert (s.u.)

public class Test extends Thread
{
    public boolean finished= false;
    public boolean running = true;
        
    public void run()
    {
        
        while(running)
        {
            // blablabla
            // ...
        }
        
        finished = true;
    }
    
    public void cancel()
    {
        running = false;
        
        while(! finished);
    }
}

 

[Rock Lobster]

Danke für eure Antworten, habe jetzt aber rausgefunden, daß es an was völlig anderem liegt

Trotzdem gut, denn Thread.join kannte ich z.B. noch gar nicht.

Mein (wirklich saublöder) Fehler: Ich habe im Thread eine Bedingung, und wenn diese zutrifft, soll der Thread gestoppt werden. Also wird dem Main-Thread gesagt, er soll den Thread abbrechen. Jetzt bleibt natürlich der Thread stehen, weil von dort aus ja die Funktion zum Abbrechen aufgerufen wurde, was bewirkt, daß gar nicht mehr zur Thread-Schleife zurückgesprungen wird und der Thread somit niemals "finished = true" erreichen kann.

Naja, jetzt muß ich hierfür halt eine gute Lösung finden. Das Problem ist, daß der Thread sich nicht einfach so von selbst beenden soll (z.B. durch ein simples return), sondern daß eigentlich schon die Funktion aus dem Main-Thread benutzt werden muß. Aber mir wird schon irgendwie was einfallen...