Discussion :

[nicogigo]

Salut,

Petite difficulté technique. J'ai créé un programme ou l'utilisateur passe des paramètres avec des boutons puis une simulation en thread s'exécute en parallèle. Le problème qui se produit est que j'ai créé un bouton pour arrêter la simulation. J'ai définit une variable Terminated initialisée à 0. La simulation s'exécute tant que que Terminated = 0. Si l'utilisateur clique sur 'Arrêter la simulation', Terminated passe à 1, et là je sors de ma boucle de calcul. Jusque là pas de problème.

Mais là où ça devient plus compliqué, c'est si je redémarre la simulation, il me dit que mon thread est déjà 'start'. Logique, avec ma méthode, mon thread n'est jamais réellement considéré comme terminé. Quelqu'un connaitrait il une méthode propre et simple pour tuer un thread?

[nicogigo]

J'avoue que j'ai un peu de mal à comprendre mais je vais analyser ça en détail à tête reposée

[airod]

as tu lu la faq?
http://python.developpez.com/faq/?page=Thread

perso avant de lancer la simulation je ferais un MonThread._Thread__stop()
pour etre sur que celui ci est détruit.

[kango]

oui oui je comprends bien tyrtamos

le t.join() rend l'exécution bloquante, en fait ma question c'est plutôt comment tu implémenterais l'exemple que je donne avec ta méthode, sachant que la fonction compteur doit rester tel quelle.

Je ne vois pas comment tu peux écrire la méthode run en fait et sans utiliser la variable globale pour le end bien entendu car toute fonction ne se limite pas à une boucle while

[tyrtamos]

@ kango:

J'ai repris ton 1er message, et: désolé, mais je n'ai pas bien compris ce que tu me demandes.

Ton 1er code fonctionne: tel que programmé, le thread s'arrête tout seul après avoir compté i jusqu'à end.

C'est seulement si tu veut l'arrêter avant que i arrive à end que le problème se pose, car il faut alors que le programme principal puisse changer la valeur d'une variable utilisée par le thread comme test de boucle while.

Voilà dans ce cas comment on pourrait coder cela avec une classe:

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
import threading, time
 
class Compteur(threading.Thread):
 
    def __init__(self, end):
        threading.Thread.__init__(self)
        self.end = end
 
    def run(self):
        i = 0
        while i < self.end:
            i += 1
            print i
            time.sleep(1)
 
    def stop(self):
        self.end = 0
 
t = Compteur(10)
t.start()
time.sleep(5)
t.stop()
 
raw_input("Fin !")

Dans cet exemple, le thread devrait durer 10 secondes, mais le programme principal l'arrête au bout de 5 secondes.

Tu vois qu'on peut se passer de variable globale, grâce au fait que l'attribut de classe self.end est initialisé et est donc dispo dans toutes les méthodes de la classe.

Quand on lance l'exécution de la méthode t.stop(), elle change self.end, ce qui arrête la boucle while du run et donc arrête le thread.

Une fois qu'on a compris comment coder les thread sous forme de classe, on considère que c'est la méthode "normale" tellement elle est pratique et puissante.

Tyrtamos

[kango]

oki, je comprends cette implémentation. mais c'est un cas très particulier ici car la méthode run contient un while.

Imaginons que la fonction que nous voulons mettre dans un thread est une lourde opération de calcul (matriciel par exemple) ou alors une opération de copie d'arborescence avec shutil.copytree()

Code :

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

1
2
3
4
5
6
7
8
9
def CopieRepertoire(threading.Thread):
 
    def __init__(self,src,dest):
        threading.Thread.__init__(self)
        self.src = src
        self.dest = dest
 
    def run(self):
        shutil.copytree(self.src,self.dest)

Comment faire ici ? Ce que je veux mettre en évidence c'est que tu peux effectivement arrêter un Thread à condition d'avoir sous-classer la classe Thread mais que ceci ne fonctionne que si la fonction à threader est spécifiquement conçue pour être arrêtée. Ce qui peut ne pas être le cas.

Du coup, il ne me semble pas qu'il y ait de solution universelle permettant de stopper les threading.Thread, quelqu'ils soient.

Le problème est différent pour les subprocess.Popen et eux pour le coup sont arrêtables

Voir aussi le module multiprocessing qui implémente des processus "lourds" du genre subprocess.Popen avec l'interface des threading.Thread.

Pour le problème que rencontre nicogigo, il semble qu'il ait un mécanisme comme celui que tu implémentes tyrtamos. Le problème est qu'un Thread ne peut pas être "start" plusieurs fois.

Du coup peut être que la solution est de recréer un nouveau Thread avec les mêmes paramètres et appeler la méthode start sur ce Thread là

En tout cas c'est ce que j'ai fait récemment, le fait de cliquer sur le bouton instancie le thread et lance le start dans la foulée. De ce fait je peux "relancer" le thread.