Thread.stop() umgehen ?

[muckelzwerg]

Ich möchte bestimmte Abläufe mit einem Timeout versehen.
Allgemein ist ja der Weg über "Thread.interrupt()" gängig.
Die run() meines Runnable führt allerdings Funktionen aus, die unbegrenzt blocken können,
ohne dass ich da reingreifen kann.
Also geht ein Check mit "isinterrupted()" nicht.
Bleibt noch die InterruptedException. In deren Behandlung kann ich das Beenden einfügen.
Wie aber stelle ich sicher, dass ein Runnable sich daran auch wirklich hält ?
Falls das Runnable nicht beenden will oder kann, müsste ich es ja doch wieder von Außen erschlagen.
Dabei ergibt sich das Problem "Wieviel Zeit bekommt der Thread, um sich selbst zu beenden ?".
Hat jemand eine Idee ?


-- -- muckelzwerg

 

[clemson]

hmm, hab ich dich da richtig verstanden: du hast eine operation, welche unter umständen ewig "dauert" bzw. blockiert, und möchtest diese beispielsweise nach 5 sekunden blockieren beenden oder aber auch schon vorher beenden?

dann wird dir möglicherweise Thread#join(long) weiterhelfen...

package org.javaforum.y06.august.thread;

public class ThreadTest
{

	public static void main(String[] args) throws InterruptedException
	{
		new ThreadTest();
	}

	private long time = System.currentTimeMillis();

	void log(String msg)
	{
		long now = System.currentTimeMillis();
		long difference = now - time;
		time = now;

		System.out.println(difference + "ms: [ThreadTest] " + msg);
	}

	public ThreadTest() throws InterruptedException
	{
		OperationThread operationThread = new OperationThread();
		operationThread.start();
		log("Operationsthread gestartet");

		// maxial 3 sekunden warten
		operationThread.join(3000);

		// sanft beenden
		log("Operationsthread wird beendet");
		operationThread.stopRunning();

		// warten, bis "sanfte" beendigt wurde (maximal 1 sekunden warten)
		operationThread.join(1000);
		log("Operationsthread beendet");
	}

}

package org.javaforum.y06.august.thread;

public class OperationThread extends Thread
{

	private boolean running = true;

	public synchronized boolean isRunning()
	{
		return running;
	}

	public synchronized void stopRunning()
	{
		System.out.println("[OperationThread] Habe Befehl zum Beenden bekommen");
		running = false;
	}

	public void run()
	{
		while (isRunning())
		{
			try
			{
				System.out.println("[OperationThread] Beginne mit der zeitraubenden Operation");
				// sleep 10 seconds
				Thread.sleep(10000);
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}

}

0ms: [ThreadTest] Operationsthread gestartet
[OperationThread] Beginne mit der zeitraubenden Operation
3000ms: [ThreadTest] Operationsthread wird beendet
[OperationThread] Habe Befehl zum Beenden bekommen
1000ms: [ThreadTest] Operationsthread beendet

 

[muckelzwerg]

Das join hatte ich ebenfalls verwendet.
Es ist nur so, dass Dein "isRunning()" evtl nur ein einziges mal geprüft wird,
und danach nie wieder.
Die run-Schleife läuft vielleicht nur ein einziges mal durch und bleibt dabei bereits hängen.
Leider muss ich in der "run()" Methoden verwenden, auf die ich keinen Einfluss habe.
Da kann also ein Vorgang enthalten sein der blockiert, und dann wird "isRunning()" nicht mehr ausgewertet.
Deshalb hatte ich alle Abbruchsfunktionalität direkt in die Behandlung der InterruptedException gelegt.
Das geht auch soweit.
Das Problem ist jetzt: Wie kann ich dem Thread die Möglichkeit geben,
sauber abzubrechen, und trotzdem sicher sein, dass er auch wirklich beendet wird ?
Ich müsste nach dem interrupt() Aufruf ein zweites join() laufen lassen, mit einer Gnadenfrist, die der Thread Zeit hat, sich zu beenden.
Das ist aber irgendwie ziemlich "kurios".
Und da das Problem immer mal wieder auftauchen kann,
wollte ich nach einer allgemeinen Lösung fragen.
Vielleicht lässt sich ja auch über Interfaces etc. das "Ich beende mich selbst" Verhalten erzwingen. Aber bisher hab ich da nichts passendes finden können.

-- -- muckelzwerg