Existe-t-il un moyen de tuer un fil?

Est-il possible de terminer un thread en cours d'exécution sans définir / vérifier aucun indicateur / sémaphores / etc.?

C'est généralement un mauvais schéma de tuer un thread brusquement, en Python et dans n'importe quelle langue. Pensez aux cas suivants:

• le thread contient une ressource critique qui doit être fermée correctement
• le thread a créé plusieurs autres threads qui doivent également être supprimés.

La bonne façon de gérer cela si vous pouvez vous le permettre (si vous gérez vos propres threads) est d'avoir un indicateur exit_request que chaque thread vérifie à intervalle régulier pour voir s'il est temps pour lui de 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,  *args, **kwargs):
        super(StoppableThread, self).__init__(*args, **kwargs)
        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()le thread lorsque vous souhaitez qu'il se termine et attendre que le thread se ferme correctement à l'aide de join(). Le thread doit vérifier le drapeau d'arrêt à intervalles réguliers.

Il y a cependant des cas où vous avez vraiment besoin de tuer un thread. Un exemple est lorsque vous encapsulez une bibliothèque externe qui est occupée pour de longs appels et que vous souhaitez l'interrompre.

Le code suivant permet (avec certaines restrictions) de lever 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 sur la valeur de retour de PyThreadState_SetAsyncExcsemble provenir d'une ancienne version de Python .)

Comme indiqué dans la documentation, ce n'est pas 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 à ce que le thread intercepte une exception spécifique et effectue le nettoyage. De cette façon, vous pouvez interrompre une tâche et toujours effectuer un nettoyage approprié.

Il n'y a pas d'API officielle pour le faire, non.

Vous devez utiliser l'API de la plate-forme pour tuer le thread, par exemple pthread_kill ou TerminateThread. Vous pouvez accéder à cette API, par exemple via pythonwin ou via ctypes.

Notez que cela est intrinsèquement dangereux. Cela entraînera probablement des déchets non collectables (à partir des variables locales des cadres de pile qui deviennent des déchets) et peut entraîner des blocages, si le thread en cours de suppression a le GIL au moment où il est tué.

Une multiprocessing.Processboîtep.terminate()

Dans les cas où je veux tuer un thread, mais que je ne veux pas utiliser de drapeaux / verrous / signaux / sémaphores / événements / quoi que ce soit, je promeut les threads en processus complets. Pour le code qui utilise seulement quelques threads, la surcharge n'est pas si mauvaise.

Par exemple, cela est pratique pour terminer facilement les "threads" d'aide qui exécutent le blocage des E / S

La conversion est triviale: dans le code associé, remplacez all threading.Threadwith multiprocessing.Processet all queue.Queuewith multiprocessing.Queueet ajoutez les appels requis de p.terminate()à votre processus parent qui veut tuer son enfantp

Voir la documentation Python pourmultiprocessing .

Si vous essayez de terminer l'ensemble du programme, vous pouvez définir le thread comme un "démon". voir Thread.daemon

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-classement de Thread, pas de variable globale), un rappel lambda est une option. (Notez les parenthèses 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 __name__ == '__main__':
    main()

Remplacement print()par une pr()fonction qui rince toujours (sys.stdout.flush() ) peut améliorer la précision de la sortie du shell.

(Testé uniquement sur Windows / Eclipse / Python3.3)

Ceci est basé sur thread2 - threads éliminables (recette Python)

Vous devez appeler PyThreadState_SetasyncExc (), qui n'est disponible que via ctypes.

Cela n'a été testé que sur Python 2.7.3, mais il est susceptible de fonctionner 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 thread sans coopérer avec lui.

Tuer un thread supprime toutes les garanties que les blocs try / finally sont configurés afin que vous puissiez laisser les verrous verrouillés, les fichiers ouverts, etc.

La seule fois où vous pouvez affirmer que tuer des threads de force est une bonne idée est de tuer un programme rapidement, mais jamais un seul thread.

En Python, vous ne pouvez tout 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 de thread , est d'utiliser le package de multitraitement . 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, tandis que sous Windows via le TerminateProcess() appel). Faites attention à l'utiliser lorsque vous utilisez une file d'attente ou un tuyau! (cela peut corrompre les données de la file d'attente / du canal)

Notez que le multiprocessing.Eventet lemultiprocessing.Semaphore travail exactement de la même manière que le threading.Eventet lethreading.Semaphore respectivement. En fait, les premiers sont des clones de ces derniers.

Si vous avez VRAIMENT besoin d'utiliser un fil, il n'y a aucun moyen de le tuer directement. Ce que vous pouvez faire, cependant, est d'utiliser un "thread démon" . En fait, en Python, un Thread peut être marqué comme démon :

yourThread.daemon = True  # set the Thread as a "daemon thread"

Le programme principal se fermera lorsqu'il ne restera plus de threads non démon vivants. En d'autres termes, lorsque votre thread principal (qui est, bien sûr, un thread non démon) terminera ses opérations, le programme se fermera même s'il reste des threads démon qui fonctionnent.

Notez qu'il est nécessaire de définir un fil comme daemon avant d' start()appeler la méthode!

Bien sûr, vous pouvez et devez 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, s'il vous plaît, notez que sys.exit()et os.kill()ne sont pas des choix.

Vous pouvez tuer un thread en installant trace dans le thread qui quittera le thread. Voir le lien ci-joint pour une implémentation possible.

Tuez un fil en Python

Si vous appelez explicitement time.sleep()dans le cadre de votre thread (par exemple, interroger un service externe), une amélioration de la méthode de Phillipe consiste à utiliser le délai d'attente dans le event'swait() méthode où que voussleep()

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()

Ensuite, pour 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 d' 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 seriez autrement sleep()ing) et à mon avis, le code de gestion de la sortie est beaucoup plus simple .

C'est mieux si vous ne tuez pas un fil. Un moyen pourrait être d'introduire un bloc "try" dans le cycle du thread et de lever une exception lorsque vous voulez arrêter le thread (par exemple un break / return / ... qui arrête votre pour / while / ...). Je l'ai utilisé sur mon application et cela fonctionne ...

Il est certainement possible d'implémenter une Thread.stopméthode comme indiqué dans 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 __name__ == '__main__':
    main()

La Thread3classe semble exécuter le code environ 33% plus rapidement que la Thread2classe.

from ctypes import *
pthread = cdll.LoadLibrary("libpthread-2.15.so")
pthread.pthread_cancel(c_ulong(t.ident))

t est votreThread objet.

Lisez la source de python ( Modules/threadmodule.cet Python/thread_pthread.h) vous pouvez voir Thread.identest un pthread_ttype, donc vous pouvez faire tout ce que vous pthreadpouvez faire en utilisation python libpthread.

La solution de contournement 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 terminer les threads, 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 terminer les threads générés dans ce module.

J'utilise habituellement cela pour terminer tous les threads à la sortie du programme. Ce n'est peut-être pas le moyen idéal pour terminer un ou plusieurs threads, mais cela peut aider.

Je suis bien en retard dans ce jeu, mais j'ai été confronté à une question similaire et les éléments suivants semblent à la fois résoudre le problème parfaitement pour moi ET me permettent de vérifier et de nettoyer l'état du thread de base lorsque le sous-thread démonifié 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]

Une chose que je veux ajouter est que si vous lisez la documentation officielle dans le 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 le drapeau que Paolo Rovelli a mentionné .

De la documentation officielle:

Les threads démons sont brusquement arrêtés à l'arrêt. Leurs ressources (telles que les fichiers ouverts, les transactions de base de données, etc.) peuvent ne pas être libérées correctement. Si vous souhaitez que vos threads s'arrêtent correctement, rendez-les non démoniaques 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 vaut mieux é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 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éteur Python s'exécutera pour les attendre. (En raison de ce démon peut vous aider si la matière ne se termine pas brusquement).

Il y a une bibliothèque construite à cet effet, stopit . Bien que certaines des mêmes mises en garde énumérées ici s'appliquent toujours, au moins cette bibliothèque présente une technique régulière et reproductible pour atteindre l'objectif déclaré.

Bien qu'il soit plutôt ancien, cela pourrait être une solution pratique pour certains:

Un petit module qui étend les fonctionnalités du module de threading - permet à un thread de lever des exceptions dans le contexte d'un autre thread. En augmentant 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 lever 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 sa source d'origine , ce code présente certains problèmes.

• L'exception ne sera levée que lors de l'exécution de bytecode python. Si votre thread appelle une fonction de blocage native / intégrée, l'exception ne sera levée que lorsque l'exécution reviendra au code python.
  • Il existe également un problème si la fonction intégrée appelle en interne PyErr_Clear (), ce qui annulerait efficacement votre exception en attente. Vous pouvez essayer de le relever à nouveau.
• Seuls les types d'exceptions peuvent être levés en toute sécurité. Les instances d'exception 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")).
  • À mon humble avis, c'est un bug, et je l'ai signalé comme un. 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 comme ctypes est devenu une bibliothèque standard (à partir de 2.5), et que cette
  fonctionnalité n'est probablement pas indépendante de l'implémentation, elle peut rester
  non exposée.

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 - dit qu'utiliser ØMQ et éviter les primitives de synchronisation comme les verrous, les mutex, les événements, etc. est la façon la plus sûre et la plus sûre d'écrire des programmes multi-threads:

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 équipant le thread d'un ØMQ-socket et en interrogeant ce socket pour un message disant qu'il devrait annuler.

Le lien fournit également un exemple de code python multi-thread avec ØMQ.

En supposant que vous souhaitez avoir plusieurs threads de la même fonction, c'est à mon humble avis la mise en œuvre la plus simple pour en arrêter un par id:

import time
from threading import Thread

def doit(id=0):
    doit.stop=0
    print("start id:%d"%id)
    while 1:
        time.sleep(1)
        print(".")
        if doit.stop==id:
            doit.stop=0
            break
    print("end thread %d"%id)

t5=Thread(target=doit, args=(5,))
t6=Thread(target=doit, args=(6,))

t5.start() ; t6.start()
time.sleep(2)
doit.stop =5  #kill t5
time.sleep(2)
doit.stop =6  #kill t6

La bonne chose est ici, vous pouvez avoir plusieurs fonctions identiques et différentes, et les arrêter toutes en functionname.stop

Si vous voulez avoir un seul thread de la fonction, vous n'avez pas besoin de vous souvenir de l'id. Arrêtez-vous si doit.stop> 0.

Juste pour développer l'idée de @ SCB (qui était exactement ce dont j'avais besoin) pour créer une sous-classe KillableThread avec une fonction personnalisée:

from threading import Thread, Event

class KillableThread(Thread):
    def __init__(self, sleep_interval=1, target=None, name=None, args=(), kwargs={}):
        super().__init__(None, target, name, args, kwargs)
        self._kill = Event()
        self._interval = sleep_interval
        print(self._target)

    def run(self):
        while True:
            # Call custom function with arguments
            self._target(*self._args)

        # 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()

if __name__ == '__main__':

    def print_msg(msg):
        print(msg)

    t = KillableThread(10, print_msg, args=("hello world"))
    t.start()
    time.sleep(6)
    print("About to kill thread")
    t.kill()

Naturellement, comme avec @SBC, le thread n'attend pas pour exécuter une nouvelle boucle pour s'arrêter. Dans cet exemple, vous verriez le message "Killing Thread" imprimé juste après le "About to kill thread" au lieu d'attendre 4 secondes de plus pour que le thread se termine (puisque nous avons déjà dormi pendant 6 secondes).

Le deuxième argument du constructeur KillableThread est votre fonction personnalisée (print_msg ici). L'argument Args sont les arguments qui seront utilisés lors de l'appel de la fonction (("hello world")) ici.

Comme mentionné dans la réponse de @ Kozyarchuk , l'installation de traces fonctionne. Puisque cette réponse ne contenait aucun code, voici un exemple fonctionnel prêt à l'emploi:

import sys, threading, time 

class TraceThread(threading.Thread): 
    def __init__(self, *args, **keywords): 
        threading.Thread.__init__(self, *args, **keywords) 
        self.killed = False
    def start(self): 
        self._run = self.run 
        self.run = self.settrace_and_run
        threading.Thread.start(self) 
    def settrace_and_run(self): 
        sys.settrace(self.globaltrace) 
        self._run()
    def globaltrace(self, frame, event, arg): 
        return self.localtrace if event == 'call' else None
    def localtrace(self, frame, event, arg): 
        if self.killed and event == 'line': 
            raise SystemExit() 
        return self.localtrace 

def f(): 
    while True: 
        print('1') 
        time.sleep(2)
        print('2') 
        time.sleep(2)
        print('3') 
        time.sleep(2)

t = TraceThread(target=f) 
t.start() 
time.sleep(2.5) 
t.killed = True

Il s'arrête après avoir imprimé 1et 2. 3n'est pas imprimé.

Vous pouvez exécuter votre commande dans un processus, puis la tuer à l'aide de l'ID de processus. J'avais besoin de synchroniser entre deux threads dont l'un ne revient pas seul.

processIds = []

def executeRecord(command):
    print(command)

    process = subprocess.Popen(command, stdout=subprocess.PIPE)
    processIds.append(process.pid)
    print(processIds[0])

    #Command that doesn't return by itself
    process.stdout.read().decode("utf-8")
    return;


def recordThread(command, timeOut):

    thread = Thread(target=executeRecord, args=(command,))
    thread.start()
    thread.join(timeOut)

    os.kill(processIds.pop(), signal.SIGINT)

    return;

Démarrez le sous-thread 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 procéder:

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 égalementthread._Thread__delete() méthode.

Je recommanderais une thread.quit()méthode pour plus de commodité. Par exemple, si vous avez un socket dans votre thread, je vous recommande de créer une quit()méthode dans votre classe socket-handle, de terminer le socket, puis d'exécuter un thread._Thread__stop()intérieur de votre quit().

Si vous avez vraiment besoin de pouvoir tuer une sous-tâche, utilisez une autre implémentation. multiprocessinget geventtous deux soutiennent sans discernement la suppression d'un «fil».

Le threading de Python ne prend pas en charge l'annulation. N'essaye même pas. Votre code est très susceptible de bloquer, de corrompre ou de fuir la mémoire, ou d'avoir d'autres effets difficiles à déboguer "intéressants" qui se produisent rarement et de manière non déterministe.