Discussion :

[DaSiX]

Bonjour à tous,

J'ai un programme qui lance plusieurs Thread. Lorsque je lance un signal sur mon processus main je voudrais qu'il termine les threads.

Mon problème est que mon programme intercepte bien les signaux mais uniquement si les threads n'ont pas été lancés.

Pour plus de clarté, voici mon code simplifié :

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
37
38
39
40
41
42
43
44
45
46
47
48
 
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
import sys
import signal
import wiringpi2 as wiringpi
import MySQLdb as mdb
from time import sleep
from threading import Thread
 
def stop_programme(signal, frame):
	print """STOP"""
	sys.exit(0)
 
signal.signal(signal.SIGINT, stop_programme)
 
...
def Fonctions
...
 
class Sequence(Thread):
	"""Chaque séquence est envoyée en Thread pour permettre une exécution parallèle"""
	def __init__(self, pinGPIO, sequenceList):
		Thread.__init__(self)
		self.pinGPIO = pinGPIO
		self.sequence = sequenceList
		self.stoprequest = False
 
	def run(self):
		"""Parcours la sequence pour écrire les états GPIO sur la pin donnée"""
		while not self.stoprequest:
			for index, elt in enumerate(self.sequence):
				# wiringpi.digitalWrite(self.pinGPIO, elt[0])
				print "Guirlande : %d" % self.pinGPIO
				sleep(elt[1])
 
	def terminate():
		self.stoprequest = True
 
try:
	...
	Début du programme
	...
	Lancement des Threads
except Exception, e:
	print repr(e)
	sys.exit(1)

Si quelqu'un aurait une solution pour résoudre mon problème ou une piste.

Merci !

[VinsS]

Salut,

Est-ce que tu conserve des références de tes threads ?

Si oui, alors mets les dans une liste et tu pourras itérer sur cette liste pour stopper tes threads.

Quelque chose dans ce genre:

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
 
def stop_programme(signal, frame):
    global seqs
    for seq in seqs:
        seq.terminate()
    sys.exit(0)
 
...
seqs = []
try:
    seq = Sequence(*args)
    seq.start()
    seqs.append(seq)
 
    deuxième thread
    troisième thread
    etc
except Exception, e:
	print repr(e)
	sys.exit(1)

[DaSiX]

Oui mes Threads sont déjà dans une liste et je voulais également faire ta solution de boucler dessus pour les terminer (cette boucle n’apparaît effectivement plus dans mon code du premier message car je testais à ce moment si le signal était intercepté et ce n'est pas le cas).
Cependant, à partir du moment où mes Threads sont lancés, mon programme n'intercepte plus les signaux (hormis le -9 bien sûr)

Sinon, est-ce que tu as une solution pour lancer justement cette boucle de fin des Threads ? Mon projet final et de pouvoir le contrôler depuis une interface web.

Merci

[wiztricks]

Salut,

Vous avez 2 méthodes pour contrôler l'arrêt des threads.
Chaque thread regarde si un Event a été positionné

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
import signal
import time
import threading
 
done = threading.Event()
 
def worker():
    while not done.is_set():
        time.sleep(0.2)
    print ('worker exits')
 
def handler(signum, frame):
    print ('Signal handler called with signal', signum)
    done.set()
 
signal.signal(signal.SIGALRM, handler)
signal.alarm(2)
 
p = threading.Thread(target=worker)
p.start()
 
while not done.is_set():
    time.sleep(0.2)
p.join()
 
signal.alarm(0)

Les threads sont déclarée "daemon".
Dans ce cas, elles sont détruites lorsque le processus "main" sort:

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
import signal
import time
import threading
 
def worker():
    while True:
        time.sleep(0.2)
 
done = False
def handler(signum, frame):
    global done
    print ('Signal handler called with signal', signum)
    done = True
 
signal.signal(signal.SIGALRM, handler)
signal.alarm(2)
 
p = threading.Thread(target=worker)
p.daemon = True
p.start()
 
while not done:
    time.sleep(0.2)
 
signal.alarm(0)

Cependant, à partir du moment où mes Threads sont lancés, mon programme n'intercepte plus les signaux (hormis le -9 bien sûr)

Ce n'est pas ce qu'est supposé faire Python.
Quelle est la version, comment a-t-ellle été construite?
Si les exemples que j'ai posté fonctionnent, il va falloir regarder ce que fait votre code (pour ignorer les signaux).

- W

[DaSiX]

Super ! Merci beaucoup wiztricks. J'ai utilisé ta 2ème solution avec les daemon car la 1ère laissait encore les Threads travaillé un peu avant de les interrompre totalement.

Du coup je ne sait pas pourquoi mon programme n'interceptait plus les signaux, mais avec tes deux solutions je pense avoir une idée :
- il y a une liste contenant tout les Threads à exécuté
- une fois les tous Threads préparés, je boucle sur la liste pour faire les .start()
- je reboucle ensuite sur cette liste pour faire les .join()

Si j'en crois les 2 codes que tu m'as fournis, je pense que c'est les join() qui bloquent l'interception. Débutant en python, je m'étais basé sur ce tuto.

Merci à tout les deux pour votre aide.

Bonne continuation

[wiztricks]

Salut,

Si j'en crois les 2 codes que tu m'as fournis, je pense que c'est les join() qui bloquent l'interception.

Lorsque daemon=False, les .join n'ont pas à être appelés avant la sortie du programme.
Et comme la sortie du programme est provoquée par la réception du signal, pas facile de vous suivre.

Par contre, un thread ne se terminera qu'après avoir testé l'Event.
La sortie du .join dépendra du temps mis entre 2 tests successifs (par le thread).

daemon = True fonctionne a tous les coups mais, si le thread doit fermer proprement des canaux d'ES... c'est plus possible.
A vous de voir.

- W