Python: Sleep-Unterbrechung im Thread

[musv]

Guten Morgen,

vor kurzem hab ich mit Python angefangen und gewöhn mich langsam dran. Jetzt hab ich ein Problem, bei dem ich nicht so recht weiterkomm. Erst mal die Grobdaten:

• Python3 mit ncurses
• Das Programm holt alle 20 Minuten Daten aus dem Internet und aktualisiert die Ansicht.
• Die UI-Darstellung erfolgt in einem eigenen Thread
• Auf Knopfdruck und Konsole-Resize sollte das sleep im Thread unterbrochen/übergangen werden, um die UI und die Daten zu aktualisieren.

[src=python]class Output(object):
def __init__(self, stdscr, aktien, bitcoin, dax, depot):
pass # viele Initialisierungen

def update_view(self, data):
while 1:
data.update()
self.__stdscr.clear()
self.__print_time()
self.__print_head()
self.__print_dax()

zeile = 5
for aktie in self.__aktien:
self.__print_aktie(zeile, aktie.get_data())
zeile += 1
zeile = self.__print_aktie(zeile, self.__bitcoin.get_data(), True)
self.__print_depot(zeile, self.__depot.get_data())
self.__stdscr.refresh()
time.sleep(1200) # <---- das da soll bei UI-Resize abgebrochen werden

def main(stdscr):
data = Data()
# Anzeigeaktualisierung in eigenem Thread
clock = threading.Thread(target=out.update_view, args=(data, ))
clock.daemon = True
clock.start()

# Abbruchroutine
while True:
event = stdscr.getch()
if event == curses.KEY_RESIZE:
pass
# sende irgendein Signal an den Thread zum Interrupt des Sleeps
if event == ord("q"):
break
[/src]

Wie krieg ich das am besten gebacken?

 

[theSplit]

Hm, also mir ist kein Weg bekannt das man ein Sleep unterbrechen kann. Aber es gibt wohl im Threading "wait" und "notify" anstelle dessen:

Das "Wait" sagt dann der Thread soll pausiert werden, bis er mit "notify" von einem anderen Thread/Stelle benachrichtigt wird und wieder starten soll oder bis ein (optionaler) Timeout von X im Wait triggered. Ist wohl genau das was du suchst.

Hier ist die offizielle Doku dazu:
https://docs.python.org/2/library/threading.html und im Detail Condition Objects

Hier auch mehr darüber.
http://effbot.org/zone/thread-synchronization.htm

Das scheint wohl der offizielle Weg zu sein.

Vielleicht lässt sich irgendwo dazu auch ein Codeschnippsel finden, wäre ich mir relativ sicher.

----

Und eine Plan-B Idee (falls du aus irgendeinem Grund nicht Wait nutzen sollen könntest) (Feld und Wiesen-Weg!! )

Spoiler

Ein Zeitstempel wann die Daten zuletzt aktualisiert sind, dieser wird immer dann refreshed wenn ein Datenupdate durchgeführt wurde.
Und einen Switch dass wenn gerade ein Update geholt wird, die Überprüfung ob 20 Minuten abgelaufen sind ausgesetzt wird, in deiner Main dann aber.
Die Main vergleicht dann den Zeitstempel, der in der Klasse gespeichert wird, mit dem jetzt.

Anstelle den Prozess also am Leben zu erhalten, startet die Main Routine einen neuen Prozess, wenn Daten geholt werden sollen und lässt diesen auch wieder sauber beenden.

Wäre glaube ich die einfachste, wenn auch vielleicht nicht "schönste"/korrekte Lösung - aber du würdest keine While schleife oder das Sleep nutzen müssen.

 

[musv]

Danke, hab's jetzt damit hinbekommen. Ein anderes Problem ist noch die nichtblockierende Abfrage der Tastatur. Hab dazu eine relativ komplexe Lösung gefunden. Bei mir hab ich's aber über ncurses realisiert.

Falls jemand mal ein ähnliches Problem hat:
[src=python]#!/usr/bin/env python3

import time
import threading
import curses


def mein_thread(scr, event, flag):
index = 0
while True:
event.wait(timeout=3)
scr.clear()
scr.addstr(2,2,'Hallo: {} - Flag {}'.format(index, flag[0]))
if flag[0] == 1: scr.addstr(2, 20, 'Update')
if flag[0] == 2: scr.addstr(2, 20, 'Und tschüß!')
flag[0] = 0
scr.refresh()
index += 1
event.clear()



def main(scr):
flag=[0]
event = threading.Event()
mythread = threading.Thread(target=mein_thread, args=(scr, event, flag, ))
mythread.daemon = True
mythread.start()
while True:
keypress = scr.getch()
if keypress == ord("q"):
flag[0]=2
event.set()
time.sleep(2)
break
if keypress == ord("u"):
flag[0]=1
event.set()

if __name__ == '__main__':
curses.wrapper(main)
[/src]

 

[virtus]

Bei Multi-Threading und wait solltest du mit Lock und Conditions arbeiten.
https://docs.python.org/2/library/threading.html
Mit Schleifen und sleep (oder unnötigen Rechenoperationen) implementierst du nur unnötiges busy-wait.