# Threads mehrmals starten



## jobu0101 (6. Dez 2009)

Hallo!

Ich wollte ein Programm schreiben, in welchem eine selbstprogrammierte Klasse, die von Thread erbt existiert. Dieser Thread soll ein paar mal gestartet werden (zwischen durch wird er über interrupt() beendet).

Die Run-Methode sieh so aus:


```
public void run() {
		while (!isInterrupted()) {
			...
		}
	}
```

Doch irgendwie gibt es immer einen Laufzeitfehler, wenn zu zweiten mal der Thread gestartet werden soll. Darf man Threads nur einmal starten oder was ist hier falsch?


----------



## javimka (6. Dez 2009)

Ja, Threads dürfen nur einmal gestartet werden. Überschreibe statt der run() des Threads die run() einer Runnable. Du machst also eine neue Klasse, die Runnable implementiert und überschreibst run(). Du machst dann eine Instanz davon, nennen wir sie mal runnable und jedesmal, wenn du sie starten willst, schreibst du:
[c]new Thread(runnable).start();[/c]

Alternativ, könntest du auch in der Klasse, die Runnable implementiert eine Methode start() machen, in der dann gerade obiger Befehl mit "this" statt "runnable" verwendet wird. Aber da musst du aufpassen, dass du das korrekt Kommentierst, das könnte auch verwirrend sein.


----------



## jobu0101 (6. Dez 2009)

Was ist denn der Gedanke dahinter, dass ein Thread nur einmal gestartet werden darf?


----------



## javimka (6. Dez 2009)

Hat wohl etwas damit zu tun, dass beim starten des Threads intern Attribute so verändert wird, dass ein korrektes Neustarten des Threads nicht gewährleistet werden kann. Ist ja auch problematisch, falls auf einem Thread, der bereits läuft mehrmals start aufgerufen wird.


----------



## jobu0101 (6. Dez 2009)

javimka hat gesagt.:


> Ja, Threads dürfen nur einmal gestartet werden. Überschreibe statt der run() des Threads die run() einer Runnable. Du machst also eine neue Klasse, die Runnable implementiert und überschreibst run(). Du machst dann eine Instanz davon, nennen wir sie mal runnable und jedesmal, wenn du sie starten willst, schreibst du:
> [c]new Thread(runnable).start();[/c]
> 
> Alternativ, könntest du auch in der Klasse, die Runnable implementiert eine Methode start() machen, in der dann gerade obiger Befehl mit "this" statt "runnable" verwendet wird. Aber da musst du aufpassen, dass du das korrekt Kommentierst, das könnte auch verwirrend sein.



Also als Unterklasse?


----------



## javimka (6. Dez 2009)

Unterklasse? was meinst du? ???:L

Wenn du etwas überschreiben willst, musst du das in der Unterklasse, na klar


----------



## jobu0101 (6. Dez 2009)

Mein vorherige Klasse, die von Thread erbte, hatte ja noch einiges mehr. Also lokale Variablen und so weiter. Soll die jetzt einfach nur Runnable implementieren? Dann müsste ich ja für jeden run eine neue Instanz dieser Klasse bilden. Doch das will ich ja nicht, weil die lokalen Objekte für jeden Run erhalten bleiben sollen. Mir ist also nicht ganz klar, wie ich meine Klassen strukturieren soll.


----------



## Painii (6. Dez 2009)

jobu0101 hat gesagt.:


> Mein vorherige Klasse, die von Thread erbte, hatte ja noch einiges mehr. Also lokale Variablen und so weiter. Soll die jetzt einfach nur Runnable implementieren? Dann müsste ich ja für jeden run eine neue Instanz dieser Klasse bilden. Doch das will ich ja nicht, weil die lokalen Objekte für jeden Run erhalten bleiben sollen. Mir ist also nicht ganz klar, wie ich meine Klassen strukturieren soll.



Am sinnvollsten ist vielleicht wenn du eine Klasse hast in der du die Logik hast.
Dann hast du eine Klasse die Runnable implementiert und dann auf deinem Logik-Objekt arbeitet.
Davon kannst du dir beliebig viele Threads bauen die dann run nutzen können.



```
public class Logik{
 public void operation(){
  //...
 }
}
```


```
public class LogikOperator{
 private Logik logik;
 public LogikOperator(Logik l){
  logik=l;
 }
 public void run(){
  logik.operation();
 }
 public static void main(String[] args){
  Logik l = new Logik();
  new Thread(new LogikOperator(l)).start(); //beliebig oft, arbeitet immer auf den gleichen Logik-Daten
 }
}
```


----------



## javimka (6. Dez 2009)

Mein Vorschlag war, dass du in deiner Klasse die von Thread erbt [c]extends Thread[/c] durch [c]implements Runnable[/c] ersetzt. Dann kannst du dieses Runnable so oft du willst in einen Thread setzen und die run() Methode ausführen, die internen Attribute bleiben dabei ständig erhalten.


----------



## jobu0101 (6. Dez 2009)

Okay, verstehe. Dann muss es aber heißen:

public class LogikOperator implements Runnable{

Oder?


----------



## jobu0101 (6. Dez 2009)

javimka hat gesagt.:


> Mein Vorschlag war, dass du in deiner Klasse die von Thread erbt [c]extends Thread[/c] durch [c]implements Runnable[/c] ersetzt. Dann kannst du dieses Runnable so oft du willst in einen Thread setzen und die run() Methode ausführen, die internen Attribute bleiben dabei ständig erhalten.



Okay. Also mit der Runnable immer wieder einen neuen Thread bauen.


----------



## javimka (6. Dez 2009)

ganz genau


----------



## jobu0101 (6. Dez 2009)

javimka hat gesagt.:


> ganz genau



Dann geht das doch aber nicht:


```
while (!isInterrupted())
```


----------



## javimka (6. Dez 2009)

Du kannst deiner Klasse ja die Methode interrupt und isInterrupted nachrüsten. Definiere ein boolean und interrupt() setzt es auf true. Dann kannst du das boolean entweder direkt in der while-Schleife verwenden oder du machst eine Methode isInterrupted(), die das boolean zurückgibt.


----------



## jobu0101 (6. Dez 2009)

Hab das jetzt so gemacht:


```
public void run() {
		interrupt = false;
		while (!interrupt) {
			...
		}
	}

	public void interrupt() {
		interrupt = true;
	}

	public void start() {
		new Thread(this).start();
	}
```

Beim Aufruf von start() und direkt danach interrupt() macht der trotzdem endlos weiter. Komisch, oder?


----------



## javimka (6. Dez 2009)

Wahrscheinlich läuft das so ab:
Thread A startet das Runnable in Thread B, aber B tut noch nichts. Zuerst ist noch Thread A dran, der interrupt aufruft und das flag aus true setzt. Dann ist Thread B an der Reihe und das run() startet und setzt das flag auf false. Dadurch stoppt die while-Schleife natürlich nicht mehr.
Setze mal vor die Methoden start() und interrupt() ein "synchronized". Das sieht dann so aus:
[c] public synchronized void start() { ... [/c]

Dadurch wird immer nur einem einzelnen Thread erlaubt, das Objekt zu modifizieren.


----------



## jobu0101 (6. Dez 2009)

Das mit dem synchronized hat nicht geholfen. Aber folgendes beendet:


```
ps.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		ps.interrupt();
```

Das heißt, du hattest recht. Das interrupt() ist schneller beim setzen des Flags.


----------



## javimka (6. Dez 2009)

Verschiebe doch das  [c]interrupt = false;[/c] in die Methode start(), dann sollte es ja auch gehen. Und synchronized brauchst du dann auch nicht mehr.


----------



## jobu0101 (6. Dez 2009)

javimka hat gesagt.:


> Verschiebe doch das  [c]interrupt = false;[/c] in die Methode start(), dann sollte es ja auch gehen. Und synchronized brauchst du dann auch nicht mehr.



Das klappt 

Ich danke euch, vor allem dir, javimka!


----------

