Discussion :

[fennec62]

Salut

Je développe un viewer de jpg pour afficher sur un ecran en pleine ecran avec plusieurs info

meteo
heure
donne sql

etc etc


En sois la fenetre principale ne charge que des photos ou valeurs

La mise a jour de la liste des photos ou valeurs prend un temps assez long qui freeze le deroulement de la fenetre principale

comment puis je alleger la chose

un python qui affiche la fenetre et lit des listes tout les 5s

un autre python qui lui s'occupe de mettre a jour les listes et les renvoyer dans le premier python

genre threads je pense

auriez vous un petit exemple a me donner

Merci de votre aide

[deusyss]

Salut,

Tu es en train de découvrir les applis graphiques avec leurs contraintes. Ce qu'il se passe en fait, c'est que l'IHM attend que ton traitement soit fini avant de continuer. Pourquoi? parque ton IHM et ton backend (ta tache de fond) partage le même thread.

Pour une appli du genre calculatrice, cela ne pose aucun soucis. Mais dès que cela se complique un peu, tu dois passer au multi thread/threading ou multiprocessing. Il y a des librairies Python pour cela (thread, threading, multiprocessing). Sur les deux premieres, une est officiellement depreciees, et on recommand d'utiliser l'autre (desole, je ne me rappelle plus laquelle). Personellement, j'utilise la multiprocessing, car elle permet de tirer pleinement profit des processeurs multicoeurs.

Les threads communiquent entre eux par flag. Les multiprocess par flag, pipe, queues. Par pipe/queue, on peut egalement transmettre des objets, ce qui s'avere tres pratique.

Mais attention toutefois, car un thread n'est pas un processus. De fait, le fonctionnement ne sera pas le même. Par exemple, un multi thread va durer un temps X pour s'executer, mais avec des taches ne monopolisant pas plus de 30% (par exemple) de processeur au maximum. Par contre, un multiprocess va mettre une durée X/10 (par exemple) avec tous les processeurs alloués à 100%.

Ce que je veux mettre en evidence ici, c'est que tu dois distinguer, pour commencer, la difference thread/process, et ensuite choisir ce qu'il te convient le mieux.

[fennec62]

Merci.

Pour ma part je souhaiterais mettre un place un processus ou thread avec un while true et un sleep qui va mettre à jour une liste globale que je pourrais donc récupérer dans mon affichage maître.

[deusyss]

Alors tout d'abord jamais de "while True", car tu ne pourra jamais sortir. Il vaut mieux un "while <variable>", et mettre ta variable à True. Ainsi si tu desires sortir, tu aura juste à passer ta variable à False.

Ensuite, effectivement, le sleep est indispensable si tu ne veut pas monopoliser le processeur. Meme une pause de 1 ms sera visible en terme d'utilisation ressource.

Si tu utilises des threads, tu fonctionnera avec des flags qui peuvent te bloquer temporairement l'IHM. Il n'y aura plus de freeze, mais tu ne pourras pas forcement interagir avec. Avec le multiprocessing et le systeme de pipe, queues, tu peux mettre un process pour l'IHM, et un pour ton backend, et les faire communiquer via pipe/queue. Ton IHM sera insi toujours dispo, même si le resultat n'est pas immediat.

PEtit precision, si tu utilises les pipes, choisit des modeles unidirectionnel, pour le côté securitaire. Les pipes sont de type unique. Si tu ecrit dedans, tu ecrase la donnée/l'objet précédent. Les queues sont par contre de type FIFO.

[wiztricks]

Salut,

thread et GUI n'utilisent pas le même modèle de threading et le mélange est source de bugs.
Ceci dit la forme de ce genre d'application est la suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import tkinter as tk
import threading
import time
 
done = threading.Event()
 
def run_thread(count=5):
    while count > 0 and not done.is_set():
        post_update(count)
        time.sleep(0.5)
        count -= 1
    post_quit()
 
def post_quit():
    app.after_idle(app.quit)
 
def post_update(count):
    app.after_idle(lambda: display.configure(text=str(count)))
 
def create_display(app=None):
    display = tk.Label(app, text='foo')
    return display
 
if __name__ == '__main__':
 
    app = tk.Tk()
 
    display = create_display(app)
    display.pack()
 
    p = threading.Thread(target=run_thread, args=(5,))
    p.start()
 
    app.mainloop()
    done.set()
    p.join()

La fonction exécutée dans la thread "poste" des mises à jour du GUI qui se traduisent par la soumission de l'appel d'un callback par la boucle évènementielle (du GUI). Avec tk ca passe par un appel à .after_idle, d'autres GUI utilisent des interfaces plus sophistiquées, mais le principe est le même: les mises à jour du GUI doivent se faire dans le thread du GUI (la thread principale du programme) car... un GUI est rarement ré-entrant.

- W

[fennec62]

Merci des infos

Pour le moment je vais passer par des listes communes pour mettre a jour tkinter

Un thread est lancer tout les x seconds qui lui ne touche en rien au gui mais met a jour une liste global sans lancer de modif sur un tk

Et de l autre cote un un tk.after qui tourne est lit la liste globale et update le gui

Cette facon peut elle fonctinner sans bug ?

En attendant que je reecrive tout le programme

Merci