Denke nicht, das das mit der Timer-Klasse aus threading möglich ist.und zwar muss ich ziemlich oft einen timer starten.
nur kann man einen thread ja nur einmal starten.
wie kann ich einen timer also wiederverwenden.
Jepp, so toll ist das nicht, doch oft vernachlässigbar. Besser ist es, einen einmal aufgemachten Thread auch zu nutzen. Die Threaderzeugung kostet halt und die max. Anzahl ist auch limitiert.weil immer wieder neue erstellen ist ja wahrscheinlich auch keine gute lösung? (oder ist das kein problem?)
Ehm, das merkst Du doch, ob die Aktion ausgeführt wurde. Oder versteh ich Dich da grad falsch?ausserdem bräuchte ich eine möglichkeit festzustellen ob Timer.cancel den timer wirklich gestoppt hat, oder ob er vorher abgelaufen ist.
Code: Alles auswählen
import threading
class RU_Timer(threading.Thread):
def __init__(self, timeout, callback, *cb_args, **cb_kwargs):
self.timeout = timeout
self.callback = callback
self.cb_args = cb_args
self.cb_kwargs = cb_kwargs
self.timeout_event = threading.Event()
self.run_event = threading.Event()
self.running = False
self.lock = threading.Lock()
self.stop_timer()
threading.Thread.__init__(self)
def stop_timer(self):
if not self.running:
return False
else:
#self.lock.acquire()
self.running = False
self.run_event.clear()
self.timeout_event.set()
#self.lock.release()
return True
def start_timer(self):
if self.running:
return False
else:
#self.lock.acquire()
self.running = True
self.timeout_event.clear()
self.run_event.set()
#self.lock.release()
return True
def run(self):
print "hello"
while(True):
#self.lock.acquire()
self.run_event.wait()
self.timeout_event.wait(self.timeout)
if self.run_event.isSet():
self.stop_timer()
self.callback(*self.cb_args, **self.cb_kwargs)
else:
print "timer stopped"
#self.lock.release() #das ist ja nicht sinn der sache, so kann ich nicht stoppen
ja das ist klar. aber ich muss (bei diesem ansatz) sicherstellen, dass beide events in einer atomaren operation gesetzt/gecleared werden. wenn das ginge würde der timer so laufen,.jerch hat geschrieben:Das geht zum Glück auch ohne Locks, da Eventsetting ja threadsafe ist.
ich brauche den timer für einen timeout mit immer der selben länge.jerch hat geschrieben: Allerdings klappt das nicht mit Deinem Thread-Loop in der derzeitigen Form. Um den zu überarbeiten, müßten wir erstmal klären, was genau Du eigentlich suchst:
wenn der thread terminiert, kann ich ihn ja nicht wiederverwenden...jerch hat geschrieben: zum Code:
Dein Thread terminiert nie, da Du kein break setzt in der while True-Schleife. Wie hier vorzugehen ist, hängt von periodisch || wiederverwendbar ab bzw. solltest Du eine Abbruchvariable testen.
Code: Alles auswählen
import threading
import time
class RU_Timer(threading.Thread):
def __init__(self, timeout, callback, *cb_args, **cb_kwargs):
self.timeout = timeout
self.callback = callback
self.cb_args = cb_args
self.cb_kwargs = cb_kwargs
self.run_event = threading.Event()
threading.Thread.__init__(self)
def stop_timer(self):
if not self.run_event.isSet():
return False
else:
self.run_event.clear()
return True
def start_timer(self):
if self.run_event.isSet():
return False
else:
self.run_event.set()
return True
def run(self):
while(True):
ticks = self.timeout
self.run_event.wait()
while(self.run_event.isSet() and ticks):
print "TICK"
ticks -= 1
time.sleep(0.1)
if self.run_event.isSet():
print "fire"
self.run_event.clear()
#self.callback(*self.cb_args, **self.cb_kwargs)
else:
print "timer stopped"
def test(a):
print a
if __name__ == "__main__":
t = RU_Timer(10, test, "timeout")
t.start()
print "start_timer"
t.start_timer()
print "stop_timer"
t.stop_timer()
print "start_timer"
t.start_timer()
Das ist richtig, nur so kann Deine Anwendung nicht sauber runterfahren (wenn überhaupt). Du brauchst doch nur auf eine boolsche Variable testen, welche Du vor App-Ende auf False setzt und so dem Thread den Stecker ziehst. Und mit einem join() klappen dann auch evtl. noch anstehende Aufräumarbeiten.wenn der thread terminiert, kann ich ihn ja nicht wiederverwenden...
Vllt. ist ja der Event scheduler ausreichend für Dein Problem.ich brauche den timer für einen timeout mit immer der selben länge.
ich muss den timer also starten können. dann tritt entweder der timeout auf. (der timer legt einen event in in eine queue).
oder ich stoppe den timer, falls das ereignis auf das ich warte innerhalb des timeout aufgetreten ist.
Freitexterklärung:ich habe den code jetzt mal geändert und nutze nur noch einen event.
verstehe aber das verhalten nicht so ganz.
wenn ich den timer starte, dann direkt stoppe und dann direkt wieder starte wird nie "timer stopped" ausgegeben.
Ja genau, die Methoden laufen innerhalb des Aufrufkontexts, hier MainThread.ist es nicht so, dass die methoden start_timer, stop_timer im main-thread laufen, von da aus die events setzen und im timer-thread dann nur auf die events reagiert wird?