Thread beenden und wieder starten?

[JayJay]

So Leute, estmal schonen guten Tag.



Problematik;
Ich habe einen Thread, der einen Prozess aufruft und wartet, bis dieser beendet wird, funktioniert alles super:

MyApp extends Thread{
	private int run(){
        try{
        	OutputList.add("app started");
        	String cmd	= app_file;
        	
        	System.out.println("ServiceApp started");

        	// start process
        	this.process = Runtime.getRuntime().exec( cmd  );
        	
        	// handle process output-data
	        BufferedReader input = new BufferedReader(new InputStreamReader(this.process.getInputStream()));

	        String line;
        	while ((line = input.readLine()) != null) {
        		//System.out.println("Out:"+line);
        		onLineOutput( line );
        	}//while

        	this.process.waitFor(); // wait for app-self termination (hier evt das problem)??
        	//this.proces
        	
        	// clean-up
        	input.close();
        	this.process.destroy();
        	
        	return this.process.exitValue();
        	//return 1;
        	
	    }catch( Exception e ){
	    	e.printStackTrace();	// print error stack
	    }
            System.out.println("app closed");
	    return -1;
	}

        public void _stop(){
        process.destroy();
        stop();
}

Wenn ich nun den Thread starte, funktioniert alles wunderbar, das Programm wird gestartet. Wenn ich nun _stop() aufrufe wird das programm ebenfalls wunderbar beendet. Nur der thread scheint sich wohl in einem "wartungszustand" zu befinden

"System.out.println("app closed");" wird nicht ausgefürtt. !!!!

Wenn ich nun erneut den Thread via "start()" aufrufen möchte klappt nix (Thread startet sich nicht mehr).


Kann mir da evt. jemand weiterhelfen?

Würde mich über eine antwort freuen

Gruß jayjay

 

[Murray]

"System.out.println("app closed");" wird nicht ausgefürtt. !!!!

Wieso sollte das denn auch der Fall sein? Beim Stoppen wird die run-Methode doch komplett "abgewürgt".

 

[tuxedo]

[erster Post-versuch wegeditiert]

Mist, hatte nicht alles gelesen.. Jetzt steht hier ein Beitrag der völlig unnötig ist ;-(

 

[Murray]

Wenn ich nun erneut den Thread via "start()" aufrufen möchte klappt nix

start

public void start()

Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.

The result is that two threads are running concurrently: the current thread (which returns from the call to the start method) and the other thread (which executes its run method).

It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution.

 

[tuxedo]

Am besten das Thread-Objekt neu anlegen....

- Alex

 

[byte]

Noch viel besser: ThreadPools verwenden (siehe Executors)!

 

[tuxedo]

Macht das auch Sinn wenn ich nur einen Thread habe der immer mal wieder läuft?

- Alex

 

[byte]

Jup, Executors#newSingleThreadExecutor() liefert Dir den entsprechenden Service dafür.

 

[tfa]

"System.out.println("app closed");" wird nicht ausgefürtt. !!!!

Wieso sollte das denn auch der Fall sein? Beim Stoppen wird die run-Methode doch komplett "abgewürgt".

Man sollte noch erwähnen, dass Thread.stop() böse[tm] ist. Diese Methode ist deprecated und sollte
niemals benutzt werden (Erklärung in den den API-Doks).

 

[Niki]

Warum leiten eigentlich die meisten von Thread ab anstelle das Runnable Interface zu implementieren? Runnable implementieren ist doch die viel schönere Variante....

 

[byte]

Unwissenheit denke ich.

 

[tuxedo]

Runnable implementieren ist doch die viel schönere Variante....

"Schönheit ist vergänglich" .. Okay, Spass bei Seite. Es gibt halt solche und solche. Und manchmal machts halt Sinn von Thread zu erben..

 

[byte]

Nein. Eigentlich nie.

 

[tuxedo]

Hmm, lass mich mal überlegen, hatte erst kürzlich nen Fall wo ich's geschickter fand ...

[update]
Mir fällt's jetzt gerade nicht mehr ein. Aber was anderes:
Was mache ich wenn ich den Thread irgendwie abfragen will... Meinetwegen den Thread arbeitet irgendwas ab und ich hab ne Art Service-Methode wo ich den aktuellen Bearbeitungsstand abfragen kann. Wie mach ich das wenn ich nur Runnable implementiere?

- Alex

 

[Niki]

Die Servicemethode braucht einfach nur die Referenz auf das Runnable Objekt. Mehr nicht

 

[tuxedo]

Oh mann. Wieso bin ich da bis jetzt noch nicht drauf gekommen?! Na manchmal sieht man echt den Wald vor lauter Bäumen nicht.

- Alex

 

[byte]

Wie mach ich das wenn ich nur Runnable implementiere?

Kannst Du doch genauso in einem Runnable implementieren wie in einem Thread. Wo ist das Problem?

MyRunnable runnable = new MyRunnable();
executor.submit(runnable);
System.out.println(runnable.getBearbeitungsstand());

 

[phyrexianer]

ich denke man nimmt eher Thread weil damit eher einen "paralellen" Prozes in Verbindung bringt.... bei Runnable einfach nur etwas was "Rennt" ;-)

 

[byte]

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread.

 

[tuxedo]

Und wo belegt das, dass man nicht von Thread erben sollte?

Gibt es denn eine "Design-Richtlinie" oder "Convention" die das belegt, oder hat sich das einfach nur "unter der Hand eingebürgert"?

Nicht dass ich das verwenden des Runnable-Weges nicht gut heißen will. Mich interessiert es einfach nur. Gibts denn, abgesehen von der Geschmackssache was besser aussieht Vor- und Nachteile?

- Alex

 

[byte]

Es geht doch nicht darum, was besser aussieht. Durch die Implementierung der Logik in einem Runnable reduzierst Du einfach die Kopplung. Wenn Du mit der aktuellen Concurrency API arbeitest, brauchst Du generell nie mehr explizit Threads erzeugen. Du arbeitest ausschließlich mit Runnables oder Callables. Das hat den großen Vorteil, dass Threads wiederverwendet werden können, was Performance bringt, da Thread-Erzeugung teuer ist. Und selbst, wenn Du nicht auf Executor und Co. baust, dann bist Du flexibler, wenn Du mit Runnables arbeitest und diese dann dem Thread übergibst. Vielleicht ändert sich zu einem späteren Zeitpunkt das Design und die Logik soll nun doch nicht mehr in einem separaten Thread laufen. Wenn Du die Logik fest in einem Thread verdrahtest, bist Du auch auf diesen Thread festgefahren. Und last but not least ist es immer besser, ein Interface zu implementieren als eine Klasse zu erweitern. Du kannst problemlos ein Runnable implementieren und gleichzeitig von einer anderen Klasse erben. Bei Threads wird das nichts.