Timeout für Methodenausführung?

[Djinndrache]

ich möchte eine Methode (nennen wir sie sendMessage()) ausführen. Das ganze darf allerdings maximal 3 Sekunden dauern, danach gibt es im Zweifelsfall einen Timeout und es geht weiter im Programm.

Meine Denkansätze:

- Ich kann vorher die Systemzeit mit System.currentTimeMillis() nehmen.
- Ich kann hinterher die Systemzeit nehmen und ein Delta berechnen. Dann weiß ich hinterher wie lang es gedauert hat

Das Problem: wenn die Methode sendMessage() länger als 3 Sekunden braucht, dann weiß ich es erst hinterher. Ich möchte aber nach 3 Sekunden spätestens abbrechen.

Kann mir jemand helfen? Vielleicht überseh ich gerade nur etwas simples...

 

[Helgon]

Das Problem: wenn die Methode sendMessage() länger als 3 Sekunden braucht, dann weiß ich es erst hinterher. Ich möchte aber nach 3 Sekunden spätestens abbrechen.

Man kann immer nur hinterher wissen ob etwas länger als 3 Sekunden gedauert hat, wie willst du das den bitte vorher wissen?

Ich würds auch über ne Zeitdifferenz machen.

Ka was du vor hast, aber vllt hilft dir das

		final long pre = System.currentTimeMillis() + 3000;

		new Thread(new Runnable() {

			
			@Override
			public void run() {
				while(System.currentTimeMillis() < pre) {}
					
				System.out.println("3s");
				
			}
		}).start();

 

[SlaterB]

@Helgon
es gibt doch Thread.sleep(3000) ?
selbst wenn einem eine Schleife besser gefällt, dann darin doch wenigstens 20ms oder so warten,
statt Mrd. Aufrufe, CPU auf 100%, würde es sich auf paar Hundert oder weniger verringern..

 

[bERt0r]

Kannst du die Methode denn irgendwie abbrechen? Threads einfach so abwürgen ist nicht die feine Art...

Jedenfalls gibts auch den SwingWorker, der hat das quasi eingebaut java - Swingworker Timeout - Stack Overflow bzw. SwingWorker#get

 

[FArt]

ExecutorService (Java Platform SE 6)

 

[Djinndrache]

Danke soweit, ich habe mal mit dem ExecutorService rumgespielt. Hier mal mein Codeansatz bisher:

class Task implements Runnable {
	public void run() {
		String s = "";
		// Zeit verschwenden (zum Testen)
		for (int i = 0; i < 100000; i++) {
			s += "s";
		}
		System.out.println("task fertig");
	}
}

public class RunnableTester {
	public static void main(String[] args) {
		ExecutorService exec = Executors.newSingleThreadExecutor();
		Future<?> result = exec.submit(new Task());
		try {
			// Szenario sollte Timeout ergeben
			result.get(250, TimeUnit.MILLISECONDS);
			System.out.println("ERFOLG");
		} catch (InterruptedException e) {
			System.out.println("Exception: Unterbrochen");
			return;
		} catch (ExecutionException e) {
			System.out.println("Exception: Execution Fehler");
		} catch (TimeoutException e) {
			System.out.println("timeout");
			result.cancel(true);
		} finally {
			exec.shutdownNow();
			if (exec.isShutdown()) {
				System.out.println("Test: Shutdown true");
			}
			if (exec.isTerminated()) {
				System.out.println("Test: Terminated true");
			}
		}
	}
}

Er sagt mir erfolgreich, dass der Task nicht in den 250ms fertig wird (Timeout). Dann shuttet er den Executor down. Aber jetzt mein Problem damit: Er führt den Thread scheinbar weiterhin aus. Er sagt am Ende "fertig", wenn der Task seine Arbeit fertig erledigt hat...

Was läuft falsch? Wie kann ich den Thread bzw. Task "besser abwürgen"?

 

[ThreadPool]

[...]Executor down. Aber jetzt mein Problem damit: Er führt den Thread scheinbar weiterhin aus. [...]

Wenn du cancel(true) an einem Future aufrufst wird an dem ausführenden Thread deines Task der Zustand gesetzt das er doch bitte unterbrechen soll. Da du keine blockierenden Methoden verwendest bei der normalerweise eine InterruptedException fliegen würde auf die du reagieren könntest musst du in deinem Task selbst für eine zeitnahe Beendigung sorgen wenn der Thread in dessen Kontext dein Task läuft unterbrochen werden soll.

class Task implements Runnable {
    public void run() {
        String s = "";
        // Zeit verschwenden (zum Testen)
        for (int i = 0; i < 100000; i++) {
            if(Thread.currentThread().isInterrupted()){
            	break;
            }
        	s += "s";
        }
        System.out.println("task fertig");
    }
}

 

[freez]

Was läuft falsch? Wie kann ich den Thread bzw. Task "besser abwürgen"?

Ich persönlich finde "abwürgen" nicht sonderlich doll. Vorrausgesetzt du hast den Code, der ausgeführt wird unter Kontrolle, kannst du in deiner Schleife ein Flag abfragen, ob sie beendet werden soll. Und von "aussen" setzt du das Flag nach 3 Sekunden auf true.

boolean stopThread = false;

public void run(){
	System.out.println("START");
	while(!stopThread){
		doAnythingImmerWiederwas();
	}
	System.out.println("ENDE");
}

public void startThread(){	
	(new Thread(this)).start();
	Thread.sleep(3000);	//Timeout
	stopThread = true;
}

Natürlich funktioniert dieser Code nur solange wie du in dem Thread die Abarbeitung beeinflussen kannst. Hast du eine Methode, die ein SQL Statement auf eine Datenbank absetzt und die läuft 10 Sekunden, wird obiger Code nicht funktionieren. Aber solange du kleine Einheiten hast, die weniger wie 3Sekunden Laufzeit benötigen, kannst du mit obigen Code dein Ziel erreichen.
Natürlich musst du den noch etwas optimieren, da er aktuell immer genau 3 Sekunden läuft, auch wenn der Thread schon fertig ist.

 

[FArt]

Natürlich funktioniert dieser Code nur solange wie du in dem Thread die Abarbeitung beeinflussen kannst.

Schlimmer noch: der Code funktioniert nur, wenn die lesenden und schreibenden Zugriffe synchronisiert werden, z.B. wenn stopThread als volatile deklariert wird oder mit synchronized gearbeitet wird.

;-)

 

[freez]

wenn stopThread als volatile deklariert wird oder mit synchronized gearbeitet wird.

Was kann denn schlimmstenfalls bei einer Boolschen Variablen passieren, die nur von einer Seite gelesen und von der anderen Seite geschrieben wird?

 

[FArt]

Was kann denn schlimmstenfalls bei einer Boolschen Variablen passieren, die nur von einer Seite gelesen und von der anderen Seite geschrieben wird?

Es kann passieren, dass der Lesende den geschriebenen Statuswechsel nicht sieht.

Java ist auch eine Insel – 9.10 Atomares und frische Werte mit volatile

 

[Crian]

Wenn der Thread beschäftigt ist (SQL, RegExp, ...) und somit nicht reagieren KANN, kann man ihn dennoch "abwürgen", unfein hin oder her?

 

[Djinndrache]

Wenn der Thread beschäftigt ist (SQL, RegExp, ...) und somit nicht reagieren KANN, kann man ihn dennoch "abwürgen", unfein hin oder her?

Um so etwas in der Art geht es mir. Ich rufe in dem Thread im Prinzip nur eine Methode auf. Diese wiederum verwendet aber fremde Bibliotheken (welche und in welcher Form ist unbekannt; Observer-Pattern. Im Prinzip benachrichtige ich einen Observer).
Ich möchte nun aber nicht, dass ein Observer mir stundenlang den Thread offenhält, daher möchte ich die Timeout-Geschichte realisieren. Ansonsten könnte ein "böser Observer" ja eine Endlossschleife oder so bauen und mein Programm "ausbremsen", wenn nicht sogar schlimmeres.