Thread Beenden?

[jiim]

Guten Morgen,

ich hab ein Problem, ich kann einen Thread nicht stoppen.. Vielleicht kann mir jemand helfen?

Ausgangslage:

1
2
3
4
5
6
7
8
9
10
public class main {
private thread t1 = null;
 
public void startThread(int c, String name) {
if (t1 == null) {
            t1 = new ThreadTest(c, name);
            t1.start();
}
}
}

und die zweite Klasse ThreadTest:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ThreadTest {
 
private int counter;
private string name;
 
public ThreadTest(int c, String n) {
counter = c;
name = n; 
}
 
public void run() {
runner(counter, name);
}
 
public void runner(int c, string n) {
for (int i = 0; i < c; i++) {
System.out.println(n);
}
}
}

Nun, meine Mainklasse erstellt einen neuen Thread, übergibt diesem Parameter über den Konstruktor... In diesen parametern ist eine Zählvariable, die besagt wie oft der übergebenen name ausgegeben werden soll..
Mir ist klar, dass ich keine endlosschleife in der run() methode habe, somit der Thread ended, wenn diese beendet ist.
Jedoch möchte ich nun den Thread über die Main methode vorzeitig beenden, das heisst noch während der Thread damit beschäftigt ist den namen auszugeben...

Hat jemand einen vorschlag wie man das realisieren könnte? thread.stop() soll ja nicht mehr benutzt werden..

Vielen Dank für Eure Hilfe!

Grüsse

Jim

[Kai008]

Ich mache es immer so das eine boolean (breaknow) reinkommt, diese eine gleichnamige public'e Methode bekommt der die Variables auf true setzt, und in der run() ne While kommt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class ThreadTest
{
    private int counter;
    private string name; //Strings schreibt man groß.
    private boolean breaknow;
 
    public ThreadTest(int c, String n)
    {
        counter = c;
        name = n; 
    }
    public void run()
    {
        while(!breaknow)
            runner(counter, name);
    }
    private void runner(int c, string n)
    {
        for (int i = 0; i < c; i++)
            if(!this.breaknow)
                System.out.println(n);
            else
                return;
    }
    public void breaknow()
    {
        this.breaknow = true;
    }
}

Oder so ähnlich, habs jetzt schnell hier in der Textarea geschrieben.

[Franz Degenhardt]

Hallo,

die Funktion der boolsche Variable "running" gibt es in der Klasse Thread bereits.
Erspart die Variable und die Zugriffmethoden. Vgl.:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ThreadTest extends Thread {
 
    public static void main(String[] args) {
        new ThreadTest().start();
    }
 
    public void run() {
        int i = 0;
        while (!isInterrupted()) {
            try {
                Thread.sleep(1000);
                System.out.print(".");
                if (i++ > 10) {
                    System.out.println("interrupting");
                    interrupt();
                }
 
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

[Thomas Darimont]

Hallo,

die Funktion der boolsche Variable "running" gibt es in der Klasse Thread bereits.
Erspart die Variable und die Zugriffmethoden. Vgl.:

das ist richtig. Die isInterrupted() bzw. interrupted() Methoden rufen eine native Methode in der Thread-Klasse auf.

1
2
3
4
5
6
/**
     * Tests if some Thread has been interrupted.  The interrupted state
     * is reset or not based on the value of ClearInterrupted that is
     * passed.
     */
    private native boolean isInterrupted(boolean ClearInterrupted);

Das Aufrufen von nativen Methoden via JNI kann mit einem gewissen overhead behaftet sein.

Deshalb kann es schon manchmal (aus Performancegründen) sinnvoll sein, doch ein eigenes "running / stopped" flag zu pflegen.

Gruß Tom

[Kai008]

Was macht der Thread bei Thread.interrupt()?
Ich weiß was ein I. vom Computer her ist, aber was passiert dann genau mit dem Thread? Ist das sowas wie Thread.yield()? Das in der API hat meine Frage auch nicht beantwortet. (Steht nur das es dem Thread verzögert, und wann dann ne Exception fliegt.)

[Franz Degenhardt]

Sehr interessant was hinter interrupt() alles steckt, ich nehme den Tip zurück, dies als Abbruchsteuerung eines Threads zu nehmen.
Ein anderes Verhalten im Gegensatz zu "boolean running; while(running){...}" ergibt sich unter den in der API beschriebenen Umständen.
Falls der Thread z.B. gerade in einem sleep() ist, würde interrupt sofort den Thread aufwecken und eine InterruptedException auslösen. Eine Setter Methode z.B. setRunning(false) kann auch aufgerufen werden, wenn der Thread gerade schläft.


vgl.: http://java.sun.com/j2se/1.4.2/docs/...tml#interrupt()

[vNeumann]

Hallo! Kleiner Tipp von mir:
Bei mir sieht der Thread immer so aus:
Dabei setzte ich eine boolean-varialbe hier z.B. "laeuft = true"
Soll der Vorgang beendet werden, setzte ich sie auf "laeuft = false".

1
2
3
4
5
6
7
8
9
10
11
12
13
class clock extends Thread {
          public void run() {
             while(laeuft) {
                //hier steht das, was du machen willst :)
                try {
                    Thread.sleep(1000);
                }
                catch(InterruptedException e) {
                   e.printStackTrace();
                }
             }
          }
    }