python - 有什么办法可以杀死线程吗？(Is there any way to kill a Thread?)

Question

是否可以在不设置/检查任何标志/信号灯/等的情况下终止正在运行的线程？

  ask by Sudden Def translate from so

Answer 1

It is generally a bad pattern to kill a thread abruptly, in Python and in any language.

(用Python和任何语言突然终止线程通常是一个错误的模式。)

Think of the following cases:

(考虑以下情况：)

• the thread is holding a critical resource that must be closed properly

  (线程持有必须正确关闭的关键资源)

• the thread has created several other threads that must be killed as well.

  (该线程创建了其他几个必须同时终止的线程。)

The nice way of handling this if you can afford it (if you are managing your own threads) is to have an exit_request flag that each threads checks on regular interval to see if it is time for it to exit.

(如果您负担得起的话（如果您要管理自己的线程），处理此问题的一种好方法是有一个exit_request标志，每个线程定期检查一次，以查看是否该退出。)

For example:

(例如：)

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

In this code, you should call stop() on the thread when you want it to exit, and wait for the thread to exit properly using join() .

(在此代码中，您希望退出线程时应在线程上调用stop() ，并使用join()等待线程正确退出。)

The thread should check the stop flag at regular intervals.

(线程应定期检查停止标志。)

There are cases however when you really need to kill a thread.

(但是，在某些情况下，您确实需要杀死线程。)

An example is when you are wrapping an external library that is busy for long calls and you want to interrupt it.

(例如，当您包装一个忙于长时间调用的外部库并且想要中断它时。)

The following code allows (with some restrictions) to raise an Exception in a Python thread:

(以下代码允许（有一些限制）在Python线程中引发Exception：)

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 )

(Based on Killable Threads by Tomer Filiba. The quote about the return value of PyThreadState_SetAsyncExc appears to be from an old version of Python .)

(（基于Tomer Filiba的Killable Threads 。有关PyThreadState_SetAsyncExc返回值的PyThreadState_SetAsyncExc似乎来自旧版本的Python 。）)

As noted in the documentation, this is not a magic bullet because if the thread is busy outside the Python interpreter, it will not catch the interruption.

(如文档中所述，这不是灵丹妙药，因为如果线程在Python解释器之外很忙，它将无法捕获中断。)

A good usage pattern of this code is to have the thread catch a specific exception and perform the cleanup.

(此代码的一个很好的用法模式是让线程捕获特定的异常并执行清理。)

That way, you can interrupt a task and still have proper cleanup.

(这样，您可以中断任务并仍然进行适当的清理。)