Est-il possible de tuer un fil?
Est-il possible de terminer un thread en cours d'exécution sans définir/vérifier les drapeaux/sémaphores/etc.?
Il est généralement mauvais de tuer un thread brusquement, en Python et dans n’importe quel langage. Pensez aux cas suivants:
- le fil contient une ressource critique qui doit être fermée correctement
- le thread a créé plusieurs autres threads qui doivent également être supprimés.
Si vous pouvez vous le permettre, si vous en avez les moyens (si vous gérez vos propres threads), vous devez avoir un indicateur exit_request que chaque thread vérifie à intervalles réguliers pour voir s'il est temps de le quitter.
Par exemple:
import threading
class StoppableThread(threading.Thread):
"""Thread class with a stop() method. The thread itself has to check
regularly for the stopped() condition."""
def __init__(self):
super(StoppableThread, self).__init__()
self._stop_event = threading.Event()
def stop(self):
self._stop_event.set()
def stopped(self):
return self._stop_event.is_set()
Dans ce code, vous devez appeler stop() sur le thread lorsque vous souhaitez le quitter et attendre que le thread se ferme correctement à l'aide de join(). Le fil doit vérifier le drapeau d'arrêt à intervalles réguliers.
Il existe cependant des cas où vous avez vraiment besoin de tuer un fil. Par exemple, vous encapsulez une bibliothèque externe occupée par de longs appels et souhaitez l'interrompre.
Le code suivant permet (avec certaines restrictions) de générer une exception dans un thread Python:
def _async_raise(tid, exctype):
'''Raises an exception in the threads with id tid'''
if not inspect.isclass(exctype):
raise TypeError("Only types can be raised (not instances)")
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid),
ctypes.py_object(exctype))
if res == 0:
raise ValueError("invalid thread id")
Elif res != 1:
# "if it returns a number greater than one, you're in trouble,
# and you should call it again with exc=NULL to revert the effect"
ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(tid), None)
raise SystemError("PyThreadState_SetAsyncExc failed")
class ThreadWithExc(threading.Thread):
'''A thread class that supports raising exception in the thread from
another thread.
'''
def _get_my_tid(self):
"""determines this (self's) thread id
CAREFUL : this function is executed in the context of the caller
thread, to get the identity of the thread represented by this
instance.
"""
if not self.isAlive():
raise threading.ThreadError("the thread is not active")
# do we have it cached?
if hasattr(self, "_thread_id"):
return self._thread_id
# no, look for it in the _active dict
for tid, tobj in threading._active.items():
if tobj is self:
self._thread_id = tid
return tid
# TODO: in python 2.6, there's a simpler way to do : self.ident
raise AssertionError("could not determine the thread's id")
def raiseExc(self, exctype):
"""Raises the given exception type in the context of this thread.
If the thread is busy in a system call (time.sleep(),
socket.accept(), ...), the exception is simply ignored.
If you are sure that your exception should terminate the thread,
one way to ensure that it works is:
t = ThreadWithExc( ... )
...
t.raiseExc( SomeException )
while t.isAlive():
time.sleep( 0.1 )
t.raiseExc( SomeException )
If the exception is to be caught by the thread, you need a way to
check that your thread has caught it.
CAREFUL : this function is executed in the context of the
caller thread, to raise an excpetion in the context of the
thread represented by this instance.
"""
_async_raise( self._get_my_tid(), exctype )
(Basé sur Killable Threads de Tomer Filiba. La citation à propos de la valeur de retour de PyThreadState_SetAsyncExc semble provenir d'une ancienne version de Python .)
Comme indiqué dans la documentation, il ne s'agit pas d'une solution miracle, car si le thread est occupé en dehors de l'interpréteur Python, il ne détectera pas l'interruption.
Un bon modèle d'utilisation de ce code consiste à demander au thread de capturer une exception spécifique et d'effectuer le nettoyage. De cette façon, vous pouvez interrompre une tâche tout en nettoyant correctement.
Il n'y a pas d'API officielle pour faire ça, non.
Vous devez utiliser l'API de la plate-forme pour tuer le fil, par exemple. pthread_kill ou TerminateThread. Vous pouvez accéder à cette API, par exemple. à travers pythonwin, ou à travers des ctypes.
Notez que cela est intrinsèquement dangereux. Cela entraînera probablement des déchets non récupérables (provenant de variables locales des cadres de pile qui deviennent des déchets) et peut conduire à des blocages si le thread en cours de suppression a le GIL au point où il est tué.
Un multiprocessing.Process peut p.terminate()
Dans les cas où je veux tuer un fil, mais que je ne veux pas utiliser de drapeaux/verrous/signaux/sémaphores/événements/peu importe, je promeuve les threads en processus complets. Pour le code qui utilise seulement quelques threads, la surcharge n'est pas si grave.
Par exemple. cela est pratique pour mettre fin facilement aux "threads" d’aide qui exécutent des E/S bloquantes
La conversion est triviale: dans le code associé, remplacez tous les threading.Thread par multiprocessing.Process et tous les queue.Queue par multiprocessing.Queue et ajoutez les appels requis de p.terminate() à votre processus parent qui souhaite le supprimer. enfant p
Si vous essayez de mettre fin au programme entier, vous pouvez définir le fil en tant que "démon". voir Thread.daemon
Ceci est basé sur thread2 - threads pouvant être tué (recette Python)
Vous devez appeler PyThreadState_SetasyncExc (), qui est uniquement disponible via ctypes.
Cela n'a été testé que sur Python 2.7.3, mais il est probable que cela fonctionne avec d'autres versions 2.x récentes.
import ctypes
def terminate_thread(thread):
"""Terminates a python thread from another thread.
:param thread: a threading.Thread instance
"""
if not thread.isAlive():
return
exc = ctypes.py_object(SystemExit)
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
ctypes.c_long(thread.ident), exc)
if res == 0:
raise ValueError("nonexistent thread id")
Elif res > 1:
# """if it returns a number greater than one, you're in trouble,
# and you should call it again with exc=NULL to revert the effect"""
ctypes.pythonapi.PyThreadState_SetAsyncExc(thread.ident, None)
raise SystemError("PyThreadState_SetAsyncExc failed")
Vous ne devez jamais tuer de force un fil sans coopérer avec celui-ci.
Tuer un thread supprime toute garantie que les tentatives/enfin bloquent la configuration, de sorte que vous puissiez laisser les verrous verrouillés, les fichiers ouverts, etc.
La seule fois où vous pouvez affirmer qu'il est judicieux de supprimer de force les threads est de tuer rapidement un programme, mais jamais de threads simples.
Comme d'autres l'ont mentionné, la norme est de définir un drapeau d'arrêt. Pour quelque chose de léger (pas de sous-classe de Thread, pas de variable globale), un rappel lambda est une option. (Notez les parenthèses dans if stop().)
import threading
import time
def do_work(id, stop):
print("I am thread", id)
while True:
print("I am thread {} doing something".format(id))
if stop():
print(" Exiting loop.")
break
print("Thread {}, signing off".format(id))
def main():
stop_threads = False
workers = []
for id in range(0,3):
tmp = threading.Thread(target=do_work, args=(id, lambda: stop_threads))
workers.append(tmp)
tmp.start()
time.sleep(3)
print('main: done sleeping; time to stop the threads.')
stop_threads = True
for worker in workers:
worker.join()
print('Finis.')
if __== '__main__':
main()
Remplacer print() par une fonction pr() toujours vidée (sys.stdout.flush()) peut améliorer la précision de la sortie du shell.
(Testé uniquement sous Windows/Eclipse/Python3.3)
En Python, vous ne pouvez simplement pas tuer un thread directement.
Si vous n'avez PAS vraiment besoin d'un thread (!), Ce que vous pouvez faire au lieu d'utiliser le package threading , est d’utiliser le package multiprocessing . Ici, pour tuer un processus, vous pouvez simplement appeler la méthode:
yourProcess.terminate() # kill the process!
Python va tuer votre processus (sous Unix via le signal SIGTERM, sous Windows via l'appel TerminateProcess()). Faites attention à l'utiliser en utilisant une file d'attente ou un tuyau! (cela pourrait corrompre les données de la file d'attente/du tuyau)
Notez que multiprocessing.Event et multiprocessing.Semaphore fonctionnent exactement de la même manière que threading.Event et threading.Semaphore respectivement. En fait, les premiers sont des clones de ces derniers.
Si vous devez VRAIMENT utiliser un fil, il n’ya aucun moyen de le tuer directement. Ce que vous pouvez faire, cependant, est d'utiliser un "fil de démon" . En fait, en Python, un fil peut être marqué en tant que démon :
yourThread.daemon = True # set the Thread as a "daemon thread"
Le programme principal se fermera quand il ne restera plus aucun thread vivant, non-démon. En d'autres termes, lorsque votre thread principal (qui est, bien sûr, un thread non démon) finira ses opérations, le programme se fermera même s'il reste encore des threads démon en fonctionnement.
Notez qu'il est nécessaire de définir un thread comme daemon avant que la méthode start() ne soit appelée!
Bien sûr, vous pouvez et devriez utiliser daemon même avec multiprocessing. Ici, lorsque le processus principal se termine, il tente de mettre fin à tous ses processus enfants démoniaques.
Enfin, veuillez noter que sys.exit() et os.kill() ne sont pas des choix.
Vous pouvez tuer un thread en installant une trace dans le thread qui le quittera. Voir le lien ci-joint pour une implémentation possible.
C'est mieux si vous ne tuez pas un fil. Une méthode pourrait consister à introduire un bloc "try" dans le cycle du thread et à lever une exception lorsque vous souhaitez arrêter le thread (par exemple, un break/return/... qui stoppe votre/tant que/...). Je l'ai utilisé sur mon application et cela fonctionne ...
Il est certainement possible d'implémenter une méthode Thread.stop comme le montre l'exemple de code suivant:
import sys
import threading
import time
class StopThread(StopIteration):
pass
threading.SystemExit = SystemExit, StopThread
class Thread2(threading.Thread):
def stop(self):
self.__stop = True
def _bootstrap(self):
if threading._trace_hook is not None:
raise ValueError('Cannot run thread with tracing!')
self.__stop = False
sys.settrace(self.__trace)
super()._bootstrap()
def __trace(self, frame, event, arg):
if self.__stop:
raise StopThread()
return self.__trace
class Thread3(threading.Thread):
def _bootstrap(self, stop_thread=False):
def stop():
nonlocal stop_thread
stop_thread = True
self.stop = stop
def tracer(*_):
if stop_thread:
raise StopThread()
return tracer
sys.settrace(tracer)
super()._bootstrap()
###############################################################################
def main():
test1 = Thread2(target=printer)
test1.start()
time.sleep(1)
test1.stop()
test1.join()
test2 = Thread2(target=speed_test)
test2.start()
time.sleep(1)
test2.stop()
test2.join()
test3 = Thread3(target=speed_test)
test3.start()
time.sleep(1)
test3.stop()
test3.join()
def printer():
while True:
print(time.time() % 1)
time.sleep(0.1)
def speed_test(count=0):
try:
while True:
count += 1
except StopThread:
print('Count =', count)
if __== '__main__':
main()
La classe Thread3 semble exécuter le code environ 33% plus rapidement que la classe Thread2.
La solution suivante peut être utilisée pour tuer un thread:
kill_threads = False
def doSomething():
global kill_threads
while True:
if kill_threads:
thread.exit()
......
......
thread.start_new_thread(doSomething, ())
Cela peut être utilisé même pour les threads de terminaison, dont le code est écrit dans un autre module, à partir du thread principal. Nous pouvons déclarer une variable globale dans ce module et l'utiliser pour mettre fin aux threads générés dans ce module.
J'utilise habituellement ceci pour terminer tous les threads à la sortie du programme. Cela peut ne pas être le moyen idéal pour terminer thread/s mais pourrait aider.
from ctypes import *
pthread = cdll.LoadLibrary("libpthread-2.15.so")
pthread.pthread_cancel(c_ulong(t.ident))
t est votre objet Thread.
Lisez la source python (Modules/threadmodule.c et Python/thread_pthread.h) vous pouvez voir que le Thread.ident est un type pthread_t, de sorte que vous pouvez tout faire pthread peut faire en python utiliser libpthread.
Si vous appelez explicitement time.sleep() dans le cadre de votre thread (par exemple, interroger un service externe), une amélioration par rapport à la méthode de Phillipe consiste à utiliser le délai d'attente de la méthode wait() de la event où que vous soyez sleep()
Par exemple:
import threading
class KillableThread(threading.Thread):
def __init__(self, sleep_interval=1):
super().__init__()
self._kill = threading.Event()
self._interval = sleep_interval
def run(self):
while True:
print("Do Something")
# If no kill signal is set, sleep for the interval,
# If kill signal comes in while sleeping, immediately
# wake up and handle
is_killed = self._kill.wait(self._interval)
if is_killed:
break
print("Killing Thread")
def kill(self):
self._kill.set()
Puis l'exécuter
t = KillableThread(sleep_interval=5)
t.start()
# Every 5 seconds it prints:
#: Do Something
t.kill()
#: Killing Thread
L'avantage d'utiliser wait() au lieu de sleep()ing et de vérifier régulièrement l'événement est que vous pouvez programmer dans des intervalles de sommeil plus longs, le thread est arrêté presque immédiatement (alors que vous auriez autrement sleep()ing) et, à mon avis, le code de gestion de la sortie est nettement plus simple.
Une chose que je veux ajouter est que si vous lisez la documentation officielle dans threading lib Python , il est recommandé d'éviter l'utilisation de threads "démoniaques", lorsque vous ne voulez pas que les threads se terminent brusquement, avec l'indicateur qui Paolo Rovelli mentionné .
De la documentation officielle:
Les threads de démon sont brusquement arrêtés à l’arrêt. Leurs ressources (telles que des fichiers ouverts, des transactions de base de données, etc.) peuvent ne pas être libérées correctement. Si vous souhaitez que vos threads s'arrêtent normalement, désactivez-les et utilisez un mécanisme de signalisation approprié, tel qu'un événement.
Je pense que la création de threads démoniaques dépend de votre application, mais en général (et à mon avis), il est préférable d'éviter de les tuer ou de les rendre démoniaques. En multitraitement, vous pouvez utiliser is_alive() pour vérifier l’état du processus et "terminer" pour les terminer (vous évitez également les problèmes de GIL). Mais vous pouvez trouver plus de problèmes, parfois, lorsque vous exécutez votre code dans Windows.
Et rappelez-vous toujours que si vous avez des "threads en direct", l'interprète Python sera lancé pour les attendre. (En raison de ce démon, vous pouvez vous aider si cela ne compte pas, finit brusquement).
Je suis bien en retard pour ce jeu, mais je me suis débattu avec ne question similaire et ce qui suit semble résoudre le problème parfaitement pour moi ET me permet de procéder à une vérification de base de l'état des threads et au nettoyage lorsque le sous-thread démonisé se termine:
import threading
import time
import atexit
def do_work():
i = 0
@atexit.register
def goodbye():
print ("'CLEANLY' kill sub-thread with value: %s [THREAD: %s]" %
(i, threading.currentThread().ident))
while True:
print i
i += 1
time.sleep(1)
t = threading.Thread(target=do_work)
t.daemon = True
t.start()
def after_timeout():
print "KILL MAIN THREAD: %s" % threading.currentThread().ident
raise SystemExit
threading.Timer(2, after_timeout).start()
Rendements:
0
1
KILL MAIN THREAD: 140013208254208
'CLEANLY' kill sub-thread with value: 2 [THREAD: 140013674317568]
Il existe une bibliothèque construite à cet effet, stopit . Bien que certaines des précautions énumérées ci-dessus s'appliquent toujours, au moins cette bibliothèque présente une technique répétable régulière pour atteindre l'objectif déclaré.
Bien que ce soit plutôt vieux, this pourrait être une solution pratique pour certains:
Un petit module qui étend les fonctionnalités du module de threading - permet à un thread de générer des exceptions dans le contexte d'un autre thread. En soulevant
SystemExit, vous pouvez enfin tuer les threads python.
import threading
import ctypes
def _async_raise(tid, excobj):
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(excobj))
if res == 0:
raise ValueError("nonexistent thread id")
Elif res > 1:
# """if it returns a number greater than one, you're in trouble,
# and you should call it again with exc=NULL to revert the effect"""
ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
raise SystemError("PyThreadState_SetAsyncExc failed")
class Thread(threading.Thread):
def raise_exc(self, excobj):
assert self.isAlive(), "thread must be started"
for tid, tobj in threading._active.items():
if tobj is self:
_async_raise(tid, excobj)
return
# the thread was alive when we entered the loop, but was not found
# in the dict, hence it must have been already terminated. should we raise
# an exception here? silently ignore?
def terminate(self):
# must raise the SystemExit type, instead of a SystemExit() instance
# due to a bug in PyThreadState_SetAsyncExc
self.raise_exc(SystemExit)
Ainsi, il permet à un "thread de déclencher des exceptions dans le contexte d'un autre thread" et de cette manière, le thread terminé peut gérer la terminaison sans vérifier régulièrement un indicateur d'abandon.
Cependant, selon son source originale , il y a quelques problèmes avec ce code.
- L'exception ne sera levée que lors de l'exécution de python bytecode. Si votre thread appelle une fonction de blocage native/intégrée, l'exception ne sera levée que lorsque l'exécution retournera au code python.
- Il existe également un problème si la fonction intégrée appelle en interne PyErr_Clear (), ce qui annulerait effectivement votre exception en attente. Vous pouvez essayer de le relever à nouveau.
- Seuls les types d'exception peuvent être levés en toute sécurité. Les instances exceptionnelles sont susceptibles de provoquer un comportement inattendu et sont donc limitées.
- Par exemple: t1.raise_exc (TypeError) et non t1.raise_exc (TypeError ("blah")).
- IMHO c'est un bug, et je l'ai signalé comme tel. Pour plus d'informations, http://mail.python.org/pipermail/python-dev/2006-August/068158.html
- J'ai demandé à exposer cette fonction dans le module de thread intégré, mais depuis que ctypes est devenu une bibliothèque standard (à partir de la version 2.5),
n’est pas susceptible d’être agnostique pour la mise en œuvre, elle peut être conservée
non exposé.
Démarrez le sous-fil avec setDaemon (True).
def bootstrap(_filename):
mb = ModelBootstrap(filename=_filename) # Has many Daemon threads. All get stopped automatically when main thread is stopped.
t = threading.Thread(target=bootstrap,args=('models.conf',))
t.setDaemon(False)
while True:
t.start()
time.sleep(10) # I am just allowing the sub-thread to run for 10 sec. You can listen on an event to stop execution.
print('Thread stopped')
break
C'est une mauvaise réponse, voir les commentaires
Voici comment le faire:
from threading import *
...
for thread in enumerate():
if thread.isAlive():
try:
thread._Thread__stop()
except:
print(str(thread.getName()) + ' could not be terminated'))
Donnez-lui quelques secondes, puis votre fil devrait être arrêté. Vérifiez également la méthode thread._Thread__delete().
Je recommanderais une méthode thread.quit() pour plus de commodité. Par exemple, si vous avez un socket dans votre thread, je vous conseillerais de créer une méthode quit() dans votre classe de socket-handle, de terminer le socket, puis d'exécuter un thread._Thread__stop() à l'intérieur de votre quit() .
Cela semble fonctionner avec pywin32 sur Windows 7
my_thread = threading.Thread()
my_thread.start()
my_thread._Thread__stop()
Pieter Hintjens - l'un des fondateurs du projet ØMQ - - explique qu'utiliser ØMQ et éviter les primitives de synchronisation comme les verrous, les mutex, les événements, etc., est le moyen le plus sûr et le plus sûr d'écrire en multi-thread programmes:
http://zguide.zeromq.org/py:all#Multithreading-with-ZeroMQ
Cela inclut de dire à un thread enfant qu'il doit annuler son travail. Cela serait fait en dotant le thread d'un ØMQ-socket et en interrogeant sur ce socket un message disant qu'il devrait s'annuler.
Le lien fournit également un exemple de code python multi-threadé avec ØMQ.