Keeping GUIs Ansprechverhalten auch bei langen Laufe Aufgaben

https://stackoverflow.com/questions/148963

02-07-2019
|

Frage

Halten Sie die GUI reagiert, während die Anwendung hat einige CPU-schwere Verarbeitung eine der Herausforderungen der effektiven GUI-Programmierung ist.

Hier ist eine gute Diskussion , wie dies in wxPython zu tun. Zusammenfassend gibt es 3 Möglichkeiten:

Verwenden Sie Threads
Verwenden Sie wxYield
Chunk die Arbeit und tun es in den IDLE-Event-Handler

Welche Methode haben Sie finden die am effektivsten sein? Techniken aus anderen Frameworks (wie Qt, GTK oder Windows API) sind ebenfalls willkommen.

Lösung

Themen. Sie sind, was ich immer für gehen, weil Sie es in jedem Rahmen tun können, die Sie benötigen.

Und wenn Sie auf Multi-Threading und eine parallele Verarbeitung in einer Sprache / Framework verwendet sind, sind Sie auf alle Frameworks gut.

Andere Tipps

Auf jeden Fall Threads. Warum? Die Zukunft ist Multi-Core. Fast jede neue CPU hat mehr als einen Kern oder wenn es nur eine hat, könnte es Hyper-Threading zu unterstützen und so vorgibt, es mehr als man hat. Um effektiv Verwendung von Multi-Core-CPUs zu machen (und Intel planieren in der nicht allzu fernen Zukunft zu 32 Kernen gehen), müssen Sie mehrere Threads. Wenn Sie alle in einem Haupt-Thread ausgeführt werden (in der Regel der UI-Thread ist der Haupt-Thread), werden die Nutzer CPUs mit 8, 16 und 1 Tag 32 Kerne und Ihre Anwendung nie verwendet mehr als einer von ihnen, IOW es läuft viel, viel langsamer als er laufen kann.

Die tatsächliche, wenn Sie eine Anwendung heute plant, würde ich von dem klassischen Design geht weg und denken Sie an einer Master / Slave-Beziehung. Ihre UI ist der Meister, es ist nur Aufgabe ist mit dem Benutzer zu interagieren. Das ist die Anzeige von Daten an den Benutzer und das Sammeln von Benutzereingaben. Jedes Mal, wenn Sie App muss „alle Daten verarbeiten“ (auch in kleinen Mengen und viel wichtiger Großen), erstellen Sie eine „Aufgabe“ jeder Art, leiten Sie diese Aufgabe zu einem Hintergrund-Thread und machen den Thread, um die Aufgabe auszuführen, Feedback an die Bereitstellung von UI (zB wie viel Prozent sie abgeschlossen ist oder nur, wenn die Aufgabe noch läuft oder nicht, so dass der UI einen „work-in-progress indicator“ zeigen kann). Wenn möglich, teilen Sie die Aufgabe in viele kleine, unabhängige Teilaufgaben und mehr als ein Hintergrundprozess laufen, Fütterung eine Teilaufgabe zu jedem von ihnen. Auf diese Weise Ihre Anwendung von Multi-Core wirklich profitieren können und erhalten schneller desto mehr Kerne CPUs haben.

Eigentlich Unternehmen wie Apple und Microsoft planen bereits, wie sie ihre nach wie vor die meisten Single-Threaded-UIs sich multithreaded zu machen. Auch mit dem Ansatz oben, einen Tag die Situation haben kann, dass die Benutzeroberfläche die Engpass selbst ist. Die Hintergrundprozesse können Daten viel schneller als die UI verarbeiten es für den Benutzer darstellen oder den Benutzer zur Eingabe auffordern. Heute sind viele UI-Frameworks sind wenig Thread-sicher, viele nicht Thread-sicher überhaupt, aber das wird sich ändern. Serienverarbeitung (tut eine Aufgabe nach der anderen) ist eine sterbende Design, parallele Verarbeitung (viele Aufgaben auf einmal zu tun) ist, wo die Zukunft geht. Schauen Sie einfach in Grafikadapter. Selbst die modernsten hat NVidia Karte eine erbärmliche Leistung, wenn man alleine in MHz / GHz des GPU bei der Verarbeitungsgeschwindigkeit aus. Wie kommt es kann den Mist aus CPUs schlagen, wenn es um 3D-Berechnungen kommt? Ganz einfach: Statt eines Polygonpunkt oder ein Textur-Pixel nach dem anderen von der Berechnung, berechnet sie viele von ihnen parallel (eigentlich eine ganze Reihe zugleich) und diese Art und Weise es einen Durchsatz erreicht, die noch CPUs Schrei macht. Z.B. die ATI X1900 (die Teilnehmer als auch zu nennen) verfügt über 48 Shader-Einheiten!

Ich denke, delayedresult ist, was Sie suchen:

http://www.wxpython.org/docs /api/wx.lib.delayedresult-module.html

Sehen Sie die wxpython Demo für ein Beispiel.

Threads oder Prozesse abhängig von der Anwendung. Manchmal ist es eigentlich am besten die GUI es sein, das eigene Programm zu haben und nur asynchrone Aufrufe an andere Programme senden, wenn es Arbeit zu tun hat. Sie werden immer noch mehrere Threads in der GUI für die Ergebnisse zu überwachen, am Ende mit, aber es kann die Dinge vereinfachen, wenn die Arbeit ist komplex getan und nicht direkt mit der GUI verbunden.

Themen - Lassen Sie uns verwenden eine einfache 2-Schicht-Ansicht (GUI, Anwendungslogik).

Die Anwendungslogik Arbeit sollte in einem separaten Python-Thread ausgeführt werden. Für asynchrone Ereignisse, die GUI-Schicht zu propagieren bis benötigen, wx die Event-System verwenden, um benutzerdefinierte Ereignisse zu veröffentlichen. wx Ereignisse der Veröffentlichung ist die Threadsicherheit, so dass Sie möglicherweise aus mehreren Kontexten tun könnten.

in der anderen Richtung Arbeiten (GUI Eingabeereignisse Anwendungslogik Triggerung), ich habe es am besten zu Hause-Rolle eines eigenen Event-System gefunden. Verwenden Sie das Queue-Modul eine Thread-sichere Art und Weise zu schieben und knallen Ereignisobjekte zu haben. Dann wird für jede synchrone Elementfunktion, koppeln sie mit einer Async-Version, die das Sync-Funktionsobjekt und die Parameter auf die Ereigniswarteschlange drückt.

Das funktioniert besonders gut, wenn nur ein einziger Anwendungslogik-Level-Betrieb kann zu einem Zeitpunkt durchgeführt werden. Der Vorteil dieses Modells ist, dass die Synchronisation einfach - jede synchrone Funktion innerhalb seiner eigenen Kontextes der Reihe nach von Anfang an funktioniert ohne Sorge des Vorkaufsrechts oder handcodierte Nachgeben zu beenden. Sie werden keine Sperren benötigen kritische Abschnitte zu schützen. Am Ende der Funktion, Posten ein Ereignis an die GUI-Schicht anzeigt, dass die Operation abgeschlossen ist.

Sie können dies skalieren mehrere Application-Level-Threads zu ermöglichen, zu existieren, aber die üblichen Bedenken mit der Synchronisation wird wieder angezeigt.

Bearbeiten - vergessen Sie die Schönheit dieser ist zu erwähnen, dass es möglich ist, vollständig die Anwendungslogik von der GUI-Code zu entkoppeln. Die Modularität hilft, wenn Sie jemals einen anderen Rahmen verwenden entscheiden oder eine Kommandozeilen-Version der App bieten verwenden. Um dies zu tun, müssen Sie einen Zwischen Event-Dispatcher (Anwendungsebene -> GUI), die von der GUI-Schicht implementiert ist.

Arbeiten mit Qt / C ++ für Win32.

Wir teilen die wichtigsten Arbeitseinheiten in verschiedenen Prozessen. Die GUI wird als separater Prozess und in der Lage, Daten von den „Arbeiter“ Prozessen zu steuern / Empfang nach Bedarf. Funktioniert gut in der heutigen Multi-Core-Welt.

Diese Antwort bezieht sich nicht auf die Frage des OP Python in Bezug auf, ist aber eher ein Meta-Antwort.

Der einfache Weg ist Fäden. Allerdings ist nicht jede Plattform hat präemptive Threading (z BREW, einige andere eingebettete Systeme) Wenn möglich, einfach Brocken, die Arbeit und tun es in den IDLE-Event-Handler.

Ein weiteres Problem, mit dem Gewinde in BREW ist, dass es nicht C ++ Stapelobjekte nicht aufzuräumen, so ist es viel zu einfach Speicher zu verlieren, wenn Sie einfach den Thread töten.

Ich verwende Fäden so die Hauptereignisschleife GUI nie blockiert.

Für einige Arten von Operationen unter Verwendung von separaten Prozessen macht sehr viel Sinn. Zurück in den Tag, entstanden eine Menge Aufwand einen Prozess Laichen. Mit moderner Hardware ist dieser Aufwand kaum noch ein Ausrutscher auf dem Bildschirm. Dies gilt insbesondere, wenn Sie einen langen laufenden Prozess sind Laichen.

Ein (diskutierbar) Vorteil ist, dass es ein einfaches konzeptionelles Modell als Threads ist, die zu mehr wartbaren Code führen könnten. Es kann auch der Code leichter zu testen machen, wie Sie Testskripte schreiben können, die diese externen Prozesse ausüben, ohne die GUI zu beteiligen zu haben. Man könnte sogar argumentieren, dass ist der primäre Vorteil.

Im Fall von Code ich auf einmal gearbeitet, das Umschalten von Threads zu separaten Prozessen zu einer Netto-Reduktion von über 5000 Zeilen Code geführt, während zur gleichen Zeit macht die GUI mehr ansprechbar, wird der Code leichter zu pflegen und zu testen, alle während der Gesamtgesamtleistung zu verbessern.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow