Czy jest jakiś sposób na zabicie wątku w Pythonie?

Nie ma oficjalnego API, aby to zrobić, nie.

Musisz użyć platform API, aby zabić wątek, np. pthread_kill, lub TerminateThread. Możesz uzyskać dostęp do takiego API np. przez pythonwin lub przez ctypes.

Zauważ, że jest to z natury niebezpieczne. Prawdopodobnie doprowadzi to do nieoczyszczalnych śmieci (od lokalnych zmiennych ramek stosu, które stają się śmieciami) i może prowadzić do blokad, jeśli wątek zabity ma GIL w momencie jego zabicia.

A multiprocessing.Process can p.terminate()

W przypadkach, gdy chcę zabić wątek, ale nie chcę używać FLAG/blokad/sygnałów/semaforów/zdarzeń/cokolwiek, promuję wątki do pełnych procesów. Dla kodu, który wykorzystuje tylko kilka wątków, narzut nie jest taki zły.

Np. jest to przydatne do łatwego zakończenia "wątków" pomocniczych, które wykonują blokowanie We / Wy

Konwersja jest trywialna: w powiązanym kodzie Zamień wszystkie threading.Thread na multiprocessing.Process i wszystkie queue.Queue na multiprocessing.Queue i dodaj wymagane wywołania p.terminate() do procesu rodzica, który chce zabić swoje dziecko p

Python doc

Jeśli próbujesz zakończyć cały program, możesz ustawić wątek jako "daemon". Zobacz też Wątek.daemon

Nigdy nie należy siłą zabijać wątku bez współpracy z nim.

Zabicie wątku usuwa wszelkie gwarancje, że try/finally blokuje ustawione tak, że można pozostawić zablokowane blokady, otwarte pliki itp.

Jedyny raz, kiedy można argumentować, że wymuszone zabijanie wątków jest dobrym pomysłem, to szybkie zabicie programu, ale nigdy pojedynczych wątków.

Jest to oparte na thread2 -- killable threads (Python recipe)

Musisz wywołać metodę PyThreadState_SetasyncExc(), która jest dostępna tylko przez ctypes.

To zostało przetestowane tylko na Pythonie 2.7.3, ale prawdopodobnie będzie działać z innymi ostatnimi 2.x releases.

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

Jak wspomnieli inni, normą jest ustawienie flagi stop. Dla czegoś lekkiego (bez podklasowania wątku, bez zmiennej globalnej), lambda callback jest opcją. (Zwróć uwagę na nawiasy w 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()

Zastąpienie print() funkcją pr(), która zawsze spłukuje (sys.stdout.flush()) może poprawić precyzję wyjścia powłoki.

(testowane tylko na Windows / Eclipse / Python3.3)

W Pythonie, po prostu nie można zabić wątku bezpośrednio.

Jeśli naprawdę nie musisz mieć wątku (!), co można zrobić, zamiast korzystać z threading package , jest użycie multiprocessing package . Tutaj, aby zabić proces, możesz po prostu wywołać metodę:

yourProcess.terminate()  # kill the process!

Python zabije twój proces (w Unixie przez sygnał SIGTERM, podczas gdy w Windows przez wywołanie TerminateProcess()). Zwróć uwagę, aby używać go podczas korzystania z kolejki albo Rura! (może uszkodzić dane w kolejce / potoku)

Zauważ, że multiprocessing.Event i multiprocessing.Semaphore działają dokładnie w ten sam sposób, odpowiednio threading.Event i threading.Semaphore. W rzeczywistości pierwsze są klonami tych ostatnich.

Jeśli naprawdę potrzebujesz użyć wątku, nie ma sposobu, aby go zabić bezpośrednio. Możesz jednak użyć "daemon thread" . W Pythonie wątek może być oznaczony jako daemon :

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

Główny program zakończy działanie, gdy nie / align = "left" / Innymi słowy, gdy twój główny wątek (który jest oczywiście nie-demonem) zakończy swoje operacje, program zakończy działanie, nawet jeśli nadal działają niektóre wątki demona.

Zauważ, że przed wywołaniem metody start() konieczne jest ustawienie wątku jako daemon!

Na koniec proszę zauważyć, że sys.exit() i os.kill() nie są wyborami.

Możesz zabić wątek, instalując trace w wątku, który zakończy wątek. Zobacz załączony link do jednej z możliwych realizacji.

Zabij wątek w Pythonie

Jest lepiej, jeśli nie zabijasz wątku. Sposobem może być wprowadzenie bloku" try " do cyklu wątku i rzucenie wyjątku, gdy chcesz zatrzymać wątek (na przykład break/return/... to zatrzymuje twoje na / chwilę/...). Użyłem tego w mojej aplikacji i działa...

Jest zdecydowanie możliwe zaimplementowanie metody Thread.stop, Jak pokazano w poniższym przykładowym kodzie:

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

Klasa Thread3 wydaje się uruchamiać kod o około 33% szybciej niż klasa Thread2.

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

T jest Twoim Thread obiektem.

Przeczytaj źródło Pythona (Modules/threadmodule.c i Python/thread_pthread.h) możesz zobaczyć Thread.ident jest typem pthread_t, więc możesz zrobić wszystko pthread może zrobić w Pythonie używać libpthread.

Chcę jeszcze dodać, że jeśli czytasz oficjalną dokumentację w threading lib Python , zaleca się unikać używania "demonicznych" wątków, gdy nie chcesz, aby wątki kończyły się nagle, z flagą, o której wspomniał Paolo Rovelli .

Z oficjalnej dokumentacji:

Wątki demona są nagle zatrzymywane podczas zamykania. Ich zasobów (takich jak otwarte pliki, transakcje bazodanowe itp.) może nie być prawidłowo zwolniony. Jeśli chcesz, aby twoje wątki się zatrzymały z wdziękiem uczyń je nie daemonicznymi i użyj odpowiedniego mechanizmu sygnalizacyjnego, takiego jak Zdarzenie.

Myślę, że tworzenie wątków daemonicznych zależy od twojej aplikacji, ale ogólnie (i moim zdaniem) lepiej unikać ich zabijania lub robienia z nich daemonicznych. W multiprocessingu możesz użyć is_alive(), aby sprawdzić status procesu i "zakończyć", aby je zakończyć(również unikasz problemów z GIL). Ale czasami możesz znaleźć więcej problemów podczas wykonywania kodu w systemie Windows.

Oraz zawsze pamiętaj, że jeśli masz "żywe wątki", interpreter Pythona będzie uruchomiony na ich oczekiwanie. (Z powodu tego daemonic może pomóc, jeśli nie ma znaczenia nagle się kończy).

Jestem spóźniony do tej gry, ale zmagałem się z podobnym pytaniem i następujące wydaje się, że oba rozwiązują problem idealnie dla mnie i pozwalają mi zrobić podstawowe sprawdzanie stanu wątku i czyszczenie, gdy daemonized sub-thread zakończy działanie: {]}

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

0
1
KILL MAIN THREAD: 140013208254208
'CLEANLY' kill sub-thread with value: 2 [THREAD: 140013674317568]

To zła odpowiedź, Zobacz komentarze

Oto Jak to zrobić:

from threading import *

...

for thread in enumerate():
    if thread.isAlive():
        try:
            thread._Thread__stop()
        except:
            print(str(thread.getName()) + ' could not be terminated'))

Daj mu kilka sekund, a Twój wątek powinien zostać zatrzymany. Sprawdź również metodę thread._Thread__delete().

Uruchom wątek podrzędny za pomocą 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

Chociaż jest dość stary, to może być dla niektórych przydatne rozwiązanie:

Mały moduł rozszerzający funkcjonalność modułu wątku -- pozwala jednemu wątkowi zgłaszać wyjątki w kontekście innego nić. Podnosząc SystemExit, możesz w końcu zabić wątki Pythona.

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)

Pozwala więc "wątkowi zgłaszać wyjątki w kontekście innego wątku" i w ten sposób zakończony wątek może obsłużyć zakończenie bez regularnego sprawdzania flaga przerwania.

Jednak, zgodnie z jego oryginalnym źródłem , są pewne problemy z tym kodem.

• wyjątek zostanie wywołany tylko podczas wykonywania bajtowego kodu Pythona. Jeśli Twój wątek wywoła natywną / wbudowaną funkcję blokowania, wyjątek zostanie podniesiony tylko wtedy, gdy wykonanie powróci do Pythona kod.
  • istnieje również problem, jeśli wbudowana funkcja wewnętrznie wywołuje PyErr_Clear (), co skutecznie anuluje Twoje wyjątek oczekujący. Możesz spróbować podnieść go ponownie.
• tylko typy WYJĄTKÓW mogą być podniesione bezpiecznie. Wyjątki mogą powodować nieoczekiwane zachowanie, a zatem są ograniczone.
  • na przykład: t1.raise_exc (TypeError), a nie t1.raise_exc (TypeError ("blah")).
  IMHO to bug, zgłosiłem go jako jeden. Aby uzyskać więcej informacji, http://mail.python.org/pipermail/python-dev/2006-August/068158.html

[18]}poprosiłem o udostępnienie tej funkcji we wbudowanym module wątku, ale ponieważ ctypes stał się standardową biblioteką (od 2.5), A to
funkcja nie może być implementowana-agnostyczna, może być przechowywana
nienaświetlone.

Pieter Hintjens -- jeden z założycieli ØMQ -project -- mówi, używając ØMQ i unikając prymitywów synchronizacji, takich jak zamki, muteksy, zdarzenia itp., jest najbezpieczniejszym i najbezpieczniejszym sposobem pisania programów wielowątkowych:

Http://zguide.zeromq.org/py:all#Multithreading-with-ZeroMQ

Obejmuje to poinformowanie wątku podrzędnego, że powinien on anulować jego pracę. Można to zrobić poprzez wyposażenie wątku w gniazdo ØMQ i wyszukanie na tym gnieździe wiadomości mówiąc, że powinno się odwołać.

Link dostarcza również przykład wielowątkowego kodu Pythona z ØMQ.

Następujące obejście może być użyte do zabicia wątku:

kill_threads = False

def doSomething():
    global kill_threads
    while True:
        if kill_threads:
            thread.exit()
        ......
        ......

thread.start_new_thread(doSomething, ())

Może być używany nawet do kończenia wątków, których kod jest zapisany w innym module, z głównego wątku. Możemy zadeklarować zmienną globalną w tym module i użyć jej do zakończenia wątków / s zrodzonych w tym module.

Zwykle używam tego do zakończenia wszystkich wątków przy wyjściu programu. Może to nie jest idealny sposób na zakończenie wątków, ale może pomóc.

Jeśli jawnie wywołujesz time.sleep() jako część swojego wątku (powiedzmy, że używasz jakiegoś zewnętrznego serwisu), ulepszeniem metody jest użycie timeoutu w metodzie event'S wait() gdziekolwiek sleep()

Na przykład:

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

Następnie uruchomić go

t = KillableThread(sleep_interval=5)
t.start()
# Every 5 seconds it prints:
#: Do Something
t.kill()
#: Killing Thread

Zaletą używania wait() zamiast sleep()ing i regularnego sprawdzania zdarzenia jest to, że można programować w dłuższych odstępach czasu snu, wątek jest zatrzymywany niemal natychmiast (gdy w przeciwnym razie byłby sleep() ing) i moim zdaniem kod do obsługi exit jest znacznie prostszy.

Istnieje Biblioteka zbudowana w tym celu, stopit . Chociaż niektóre z tych samych ostrzeżeń wymienionych w niniejszym dokumencie nadal obowiązują, przynajmniej ta biblioteka prezentuje regularną, powtarzalną technikę osiągnięcia określonego celu.

Wygląda na to, że działa z pywin32 na windows 7

my_thread = threading.Thread()
my_thread.start()
my_thread._Thread__stop()

Możesz wykonać polecenie w procesie, a następnie go zabić, używając identyfikatora procesu. Musiałem zsynchronizować dwa wątki, z których jeden nie wraca sam.

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;

Jeśli naprawdę potrzebujesz możliwości zabicia podrzędnego zadania, użyj alternatywnej implementacji. multiprocessing i gevent oba wspierają bezkrytycznie zabijanie "wątku".

Wątek Pythona nie obsługuje anulowania. Nawet nie próbuj. Twój kod może zablokować, uszkodzić lub wyciekać pamięć lub mieć inne niezamierzone "interesujące" trudne do debugowania efekty, które zdarzają się rzadko i nieoznaczoności.