[python 2.7] Stopper un thread grâce à atexit.register

Version imprimable

Salut,

Je n'arrive pas à arrêter un thread en utilisant atexit.register Peut-être n'est-ce pas possible? peut être ai-je raté quelque chose? J'ai remarqué que quand je commente la ligne task.open(), la fonction quitApp s'exécute bien à la sortie, alors que si les threads sont actifs elle ne s'exécute pas.

Code:

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
import threading
import sys
import time
import atexit
 
class DUMMY_THREAD():
    def __init__(self, text='.', period=1.0):
        self.__running = False
        self.__period = float(period)
        self.__text = text
        self.__thread = None
        self.__id = "DUMMY_THREAD(\"%s\")"%self.__text
 
    def __str__(self):
        return self.__id
 
    def open(self, *args, **kwds):
        if not self.__running:
            self.__running = True
            self.__thread = threading.Thread(None, self.task, self.__id)
            sys.stdout.write("%s open!\n"%str(self.__thread))
            self.__thread.start()
 
    def close(self):
        if self.__running:
            sys.stdout.write("%s closed!\n"%str(self.__thread))
            self.__running = False
 
    def task(self):
        sys.stdout.write("%s started!\n"%str(self.__thread))
        target = time.time() + self.__period
        while self.__running:
            if time.time() < target:
                time.sleep(0.001)
            else:
                target += self.__period
                sys.stdout.write(self.__text)
        sys.stdout.write("%s terminated!\n"%str(self.__thread))
 
if __name__ == "__main__":
 
    import Tkinter as tk
 
    def quitApp(*args):
        print "quitApp %s"%" ".join(args)
 
    texts = ["-", "+", "*", "/", "\n"]
    for index in range(len(texts)):
        task = DUMMY_THREAD(texts[index])
        task.open()
        atexit.register(task.close)
    atexit.register(lambda:quitApp("azerty", "qwerty"))
 
    raw_input("hit RETURN to stop threads")
    print "should stop..."

A+

Pfeuh

06/08/2014, 12h23
Invité

Bonjour,

Je ne comprends pas trop l'intérêt de la torture ? :mrgreen:

Si le but est d'arrêter des threads au moment de quitter le processus principal qui les utilise (au moment de quitter le script), ce n'est pas utile : lorsqu'un processus est fermé, tous les threads qui lui sont rattachés sont automatiquement fermés aussi.

So what ?

@+.
06/08/2014, 12h26
pfeuh

Je suppose que tu n'as pas lancé le script? Il n'y a rien qui s'arrête quand le script arrive au bout. Les threads empêchent le programme de s'arrêter.

Hello,

Deux possibilités très simples à mettre en oeuvre :
- Passer le flag monthread.deamon à True. À la fin du script, les threads seront tués salement (ce qui fait que s'ils devaient executer quelque chose à la fermeture, ça se fera pas)
- Utiliser un threading.Event() pour signaler à tes threads qu'ils doivent se terminer proprement.

Un exemple simple :
Code:

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 import threading import time class MyThread(threading.Thread): def __init__(self, name, stop): super(MyThread, self).__init__() self._name = name self._stop = stop def run(self): x = 0 while not self._stop.is_set(): x += 1 print "%s -> %s" % (self._name, x) time.sleep(.5) print "tchuss" stop = threading.Event() t1 = MyThread('thread 1', stop) t2 = MyThread('thread 2', stop) t1.start() t2.start() time.sleep(5) print "arret des threads" stop.set()
Edit : Complément d'information. Il est impossible d'utiliser atexit pour terminer les threads vu qu'ils empêchent le script de se terminer tant qu'ils sont exécutés.

Merci pour cette réponse. En fait, ma question n'était pas "comment arrêter les threads", je peux le faire assez simplement en remplaçant l'ancien "main" par celui-ci, ça fonctionne très bien:
Code:

1 2 3 4 5 6 7 8 9 10 11 texts = ["-", "+", "*", "/", "\n"] tasks = [] for index in range(len(texts)): task = DUMMY_THREAD(texts[index]) task.open() tasks.append(task) raw_input("hit RETURN to stop threads") print "should stop..." tasks.reverse() [task.close() for task in tasks]
Me question était plutôt "Pourquoi ne puis-je pas enregistrer (grâce à atexit.register) une fonction qui arrête un thread?". Et corollaire, pourquoi le fait d'enregistrer cette fonction empêche les autres fonctions enregistrées (et qui n'ont rien à voir avec les threads, comme la fonction quitApp de mon premier post) de s'exécuter. Pour s'en convaincre, il suffit d'y commenter la ligne 51 task.open()... Comme son absence empêche les trheads de démarrer, la fonction quitApp s'exécute correctement.

06/08/2014, 14h27
Petibidon

J'ai édité mon message précédent pendant que tu écrivais le tien semble-t-il ;)
06/08/2014, 14h36
pfeuh

Bon, ben merci beaucoup... Au moins maintenant c'est clair! :)