blocks|key|1680393|text|multiprocessing.Process可以p.terminate()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1680394|在我想要杀死一个线程，但又不想使用flags/locks/signals/semaphores/events/whatever，的情况下，我会将线程提升到完全成熟的进程。对于只使用几个线程的代码来说，开销并不是那么糟糕。|1680395|例如，这可以方便地终止执行阻塞I/O的帮助器“线程”|1680396|转换很简单:在相关代码中，将所有threading.Thread替换为multiprocessing.Process，将所有queue.Queue替换为multiprocessing.Queue，并将所需的p.terminate()调用添加到要杀死其子p的父进程中|1680397|请参阅Python+documentation+for+multiprocessing。|1680398|示例：|1680399|import+multiprocessing
proc+=+multiprocessing.Process(target=your_proc_function,+args=())
proc.start()
#+Terminate+the+process
proc.terminate()++#+sends+a+SIGTERM|code-block|syntax|javascript|1680400|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/library/multiprocessing.html#multiprocessing.Process|1|https://docs.python.org/library/multiprocessing.html#multiprocessing.Process.terminate|2|https://docs.python.org/library/multiprocessing.html^0|0|N|P|D|0|N|0|P|D|1|0|0|0|G|G|Z|N|1Q|B|24|L|2V|D|3I|1|0|S|F|3|14|2|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|F|3|G|5|6|7|1H|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1I|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@$9|1Z|A|20|1|21]]|E|$]]|$1|N|3|O|5|6|7|22|8|@]|D|@]|E|$]]|$1|P|3|Q|5|R|7|23|8|@]|D|@]|E|$S|T]]|$1|U|3|-4|5|6|7|24|8|@]|D|@]|E|$]]]|V|$W|$5|X|Y|Z|E|$10|11]]|12|$5|X|Y|Z|E|$10|13]]|14|$5|X|Y|Z|E|$10|15]]]]

A <a href="https://docs.python.org/library/multiprocessing.html#multiprocessing.Process" rel="noreferrer"><code>multiprocessing.Process</code></a> can <a href="https://docs.python.org/library/multiprocessing.html#multiprocessing.Process.terminate" rel="noreferrer"><code>p.terminate()</code></a>
In the cases where I want to kill a thread, but do not want to use flags/locks/signals/semaphores/events/whatever, I promote the threads to full blown processes. For code that makes use of just a few threads the overhead is not that bad.
E.g. this comes in handy to easily terminate helper &quot;threads&quot; which execute blocking I/O
The conversion is trivial: In related code replace all <code>threading.Thread</code> with <code>multiprocessing.Process</code> and all <code>queue.Queue</code> with <code>multiprocessing.Queue</code> and add the required calls of <code>p.terminate()</code> to your parent process which wants to kill its child <code>p</code>
See the <a href="https://docs.python.org/library/multiprocessing.html" rel="noreferrer">Python documentation for <code>multiprocessing</code></a>.
Example:
<pre class="lang-py prettyprint-override"><code>import multiprocessing
proc = multiprocessing.Process(target=your_proc_function, args=())
proc.start()
# Terminate the process
proc.terminate() # sends a SIGTERM
</code></pre>

blocks|key|1465016|text|没有官方的API可以做到这一点，没有。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1465017|您需要使用平台接口来杀死线程，例如pthread_kill或TerminateThread。您可以通过pythonwin或ctypes等方式访问此类API。|1465018|请注意，这本质上是不安全的。这可能会导致无法收集的垃圾(从堆栈帧的局部变量变成垃圾)，并可能导致死锁，如果被杀死的线程在它被杀死时具有GIL。|1465019|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

There is no official API to do that, no.

You need to use platform API to kill the thread, e.g. pthread_kill, or TerminateThread. You can access such API e.g. through pythonwin, or through ctypes.

Notice that this is inherently unsafe. It will likely lead to uncollectable garbage (from local variables of the stack frames that become garbage), and may lead to deadlocks, if the thread being killed has the GIL at the point when it is killed.

blocks|key|1465123|text|如果你试图终止整个程序，你可以将线程设置为“守护进程”。请参阅Thread.daemon|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1465124|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/threading.html#threading.Thread.daemon^0|V|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If you are trying to terminate the whole program you can set the thread as a "daemon". see
<a href="http://docs.python.org/library/threading.html#threading.Thread.daemon" rel="noreferrer">Thread.daemon</a>

blocks|key|1680562|text|正如其他人所提到的，规范是设置一个停止标志。对于轻量级的东西(没有Thread的子类化，没有全局变量)，lambda回调是一种选择。(请注意if+stop()中的括号。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1680563|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()|code-block|syntax|javascript|1680564|将print()替换为始终刷新的pr()函数(sys.stdout.flush())可能会提高外壳输出的精度。|1680565|(仅在Windows/Eclipse/Python3.3上测试)|1680566|entityMap^0|1Y|9|0|0|1|7|G|4|N|I|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

As others have mentioned, the norm is to set a stop flag. For something lightweight (no subclassing of Thread, no global variable), a lambda callback is an option. (Note the parentheses in <code>if stop()</code>.)

<pre><code>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()
</code></pre>

Replacing <code>print()</code> with a <code>pr()</code> function that always flushes (<code>sys.stdout.flush()</code>) may improve the precision of the shell output.

(Only tested on Windows/Eclipse/Python3.3)

blocks|key|1465206|text|这是基于thread2+--+killable+threads+(Python+recipe)的|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1465207|您需要调用PyThreadState_SetasyncExc()，它只能通过ctypes获得。|1465208|这只在Python+2.7.3上进行了测试，但它很可能与其他最近的2.x版本一起工作。|1465209|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")|code-block|syntax|javascript|1465210|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/496960-thread2-killable-threads/^0|4|17|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

This is based on <a href="http://code.activestate.com/recipes/496960-thread2-killable-threads/">thread2 -- killable threads (Python recipe)</a>

You need to call PyThreadState_SetasyncExc(), which is only available through ctypes.

This has only been tested on Python 2.7.3, but it is likely to work with other recent 2.x releases.

<pre><code>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 &gt; 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")
</code></pre>

blocks|key|1464951|text|你不应该在没有与之合作的情况下强行杀死一个线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1464952|杀死一个线程会移除try/finally块设置的所有保证，因此您可能会保持锁定、文件打开等状态。|1464953|你唯一可以争辩说强行杀死线程是一个好主意的时候是快速杀死一个程序，而不是单个线程。|1464954|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

You should never forcibly kill a thread without cooperating with it.

Killing a thread removes any guarantees that try/finally blocks set up so you might leave locks locked, files open, etc.

The only time you can argue that forcibly killing threads is a good idea is to kill a program fast, but never single threads.

blocks|key|1681002|text|如果您显式地调用time.sleep()作为线程的一部分(例如轮询一些外部服务)，则对Phillipe方法的一个改进是，无论您在何处使用event的wait()方法中的sleep()，都可以使用超时|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1681003|例如：|1681004|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()|code-block|syntax|javascript|1681005|然后运行它|1681006|t+=+KillableThread(sleep_interval=5)
t.start()
#+Every+5+seconds+it+prints:
#:+Do+Something
t.kill()
#:+Killing+Thread|1681007|使用wait()而不是sleep()并定期检查事件的优点是，您可以在更长的休眠间隔中编程，线程几乎立即停止(否则您将退出)，而且在我看来，处理sleep()的代码要简单得多。|1681008|entityMap^0|8|C|1W|5|22|6|2C|7|0|0|0|0|0|2|6|B|7|1Z|7|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|T|$]]

If you are explicitly calling <code>time.sleep()</code> as part of your thread (say polling some external service), an improvement upon Phillipe's method is to use the timeout in the <code>event</code>'s <code>wait()</code> method wherever you <code>sleep()</code>

For example:

<pre><code>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()
</code></pre>

Then to run it

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

The advantage of using <code>wait()</code> instead of <code>sleep()</code>ing and regularly checking the event is that you can program in longer intervals of sleep, the thread is stopped almost immediately (when you would otherwise be <code>sleep()</code>ing) and in my opinion, the code for handling exit is significantly simpler.

blocks|key|1465098|text|可以通过将跟踪安装到将退出线程的线程中来终止该线程。请参阅附件中的一个可能的实现链接。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1465099|Kill+a+thread+in+Python|offset|length|1465100|entityMap|0|LINK|mutability|MUTABLE|url|https://web.archive.org/web/20130503082442/http://mail.python.org/pipermail/python-list/2004-May/281943.html^0|0|0|N|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

You can kill a thread by installing trace into the thread that will exit the thread. See attached link for one possible implementation.

<a href="https://web.archive.org/web/20130503082442/http://mail.python.org/pipermail/python-list/2004-May/281943.html" rel="noreferrer">Kill a thread in Python</a>

blocks|key|1680254|text|如果你不杀掉一个线程会更好。一种方法是在线程的循环中引入"try“块，并在想要停止线程时抛出异常(例如，中断/返回/...这会停止您的for/while/...)。我已经在我的应用程序上使用了它，它起作用了……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1680255|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It is better if you don't kill a thread.
A way could be to introduce a "try" block into the thread's cycle and to throw an exception when you want to stop the thread (for example a break/return/... that stops your for/while/...). 
I've used this on my app and it works...

blocks|key|1680528|text|实现Thread.stop方法绝对是可能的，如下面的示例代码所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1680529|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()+%25+1)
++++++++time.sleep(0.1)


def+speed_test(count=0):
++++try:
++++++++while+True:
++++++++++++count+%2B=+1
++++except+StopThread:
++++++++print('Count+=',+count)

if+__name__+==+'__main__':
++++main()|code-block|syntax|javascript|1680530|与Thread2类相比，Thread3类运行代码的速度大约快33%25。|1680531|entityMap^0|2|B|0|0|1|7|C|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

It is definitely possible to implement a <code>Thread.stop</code> method as shown in the following example code:

<pre><code>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()
</code></pre>

The <code>Thread3</code> class appears to run code approximately 33% faster than the <code>Thread2</code> class.

blocks|key|1681120|text|我玩这个游戏太晚了，但我一直在努力使用a+similar+question，下面的方法似乎都完美地为我解决了这个问题，并让我在守护化子线程退出时执行一些基本的线程状态检查和清理：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1681121|import+threading
import+time
import+atexit

def+do_work():

++i+=+0
++@atexit.register
++def+goodbye():
++++print+("'CLEANLY'+kill+sub-thread+with+value:+%25s+[THREAD:+%25s]"+%25
+++++++++++(i,+threading.currentThread().ident))

++while+True:
++++print+i
++++i+%2B=+1
++++time.sleep(1)

t+=+threading.Thread(target=do_work)
t.daemon+=+True
t.start()

def+after_timeout():
++print+"KILL+MAIN+THREAD:+%25s"+%25+threading.currentThread().ident
++raise+SystemExit

threading.Timer(2,+after_timeout).start()|code-block|syntax|javascript|1681122|收益率：|1681123|0
1
KILL+MAIN+THREAD:+140013208254208
'CLEANLY'+kill+sub-thread+with+value:+2+[THREAD:+140013674317568]|1681124|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/50473309/2123176^0|J|I|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

I'm way late to this game, but I've been wrestling with <a href="https://stackoverflow.com/q/50473309/2123176">a similar question</a> and the following appears to both resolve the issue perfectly for me AND lets me do some basic thread state checking and cleanup when the daemonized sub-thread exits:

<pre><code>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()
</code></pre>

Yields:

<pre><code>0
1
KILL MAIN THREAD: 140013208254208
'CLEANLY' kill sub-thread with value: 2 [THREAD: 140013674317568]
</code></pre>

blocks|key|1680847|text|以下解决方法可用于终止线程：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1680848|kill_threads+=+False

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

thread.start_new_thread(doSomething,+())|code-block|syntax|javascript|1680849|这甚至可以用于终止来自主线程的线程，这些线程的代码是在另一个模块中编写的。我们可以在该模块中声明一个全局变量，并使用它来终止在该模块中产生的线程。|1680850|我通常使用它在程序退出时终止所有线程。这可能不是终止线程的完美方式，但可能会有所帮助。|1680851|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Following workaround can be used to kill a thread:

<pre><code>kill_threads = False

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

thread.start_new_thread(doSomething, ())
</code></pre>

This can be used even for terminating threads, whose code is written in another module, from main thread. We can declare a global variable in that module and use it to terminate thread/s spawned in that module.

I usually use this to terminate all the threads at the program exit. This might not be the perfect way to terminate thread/s but could help.

blocks|key|1466148|text|这是另一种方法，但是使用非常干净和简单的代码，它将在2021年在Python+3.7中工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1466149|import+ctypes+

def+kill_thread(thread):
++++"""
++++thread:+a+threading.Thread+object
++++"""
++++thread_id+=+thread.ident
++++res+=+ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id,+ctypes.py_object(SystemExit))
++++if+res+>+1:
++++++++ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id,+0)
++++++++print('Exception+raise+failure')|code-block|syntax|javascript|1466150|改编自：https://www.geeksforgeeks.org/python-different-ways-to-kill-a-thread/|offset|length|1466151|entityMap|0|LINK|mutability|MUTABLE|url|https://www.geeksforgeeks.org/python-different-ways-to-kill-a-thread/^0|0|0|4|1X|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Here's yet another way to do it, but with extremely clean and simple code, that works in Python 3.7 in 2021:
<pre><code>import ctypes 

def kill_thread(thread):
 &quot;&quot;&quot;
 thread: a threading.Thread object
 &quot;&quot;&quot;
 thread_id = thread.ident
 res = ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id, ctypes.py_object(SystemExit))
 if res &gt; 1:
 ctypes.pythonapi.PyThreadState_SetAsyncExc(thread_id, 0)
 print('Exception raise failure')
</code></pre>
Adapted from here: <a href="https://www.geeksforgeeks.org/python-different-ways-to-kill-a-thread/" rel="noreferrer">https://www.geeksforgeeks.org/python-different-ways-to-kill-a-thread/</a>

blocks|key|1465924|text|有一个为此目的构建的库stopit。尽管这里列出的一些相同的注意事项仍然适用，但至少这个库提供了一种常规的、可重复的技术来实现所述目标。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1465925|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.org/project/stopit/^0|B|6|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

There is a library built for this purpose, <a href="https://pypi.org/project/stopit/" rel="nofollow noreferrer">stopit</a>. Although some of the same cautions listed herein still apply, at least this library presents a regular, repeatable technique for achieving the stated goal.

blocks|key|1681369|text|根据@SCB的想法(这正是我所需要的)，创建一个具有自定义函数的KillableThread子类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1681370|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()|code-block|syntax|javascript|1681371|当然，就像@SBC一样，线程不需要等待运行新的循环就会停止。在本例中，您将看到"Killing“消息紧跟在"About+to+kill+Thread”之后，而不是等待4秒以等待线程完成(因为我们已经休眠了6秒)。|1681372|KillableThread构造函数中的第二个参数是您的自定义函数(此处为print_msg)。Args参数是在这里调用函数(("hello+world"))时使用的参数。|1681373|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just to build up on @SCB's idea (which was exactly what I needed) to create a KillableThread subclass with a customized function:
<pre><code>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(&quot;Killing Thread&quot;)

 def kill(self):
 self._kill.set()

if __name__ == '__main__':

 def print_msg(msg):
 print(msg)

 t = KillableThread(10, print_msg, args=(&quot;hello world&quot;))
 t.start()
 time.sleep(6)
 print(&quot;About to kill thread&quot;)
 t.kill()
</code></pre>
Naturally, like with @SBC, the thread doesn't wait to run a new loop to stop. In this example, you would see the &quot;Killing Thread&quot; message printed right after the &quot;About to kill thread&quot; instead of waiting for 4 more seconds for the thread to complete (since we have slept for 6 seconds already).
Second argument in KillableThread constructor is your custom function (print_msg here). Args argument are the arguments that will be used when calling the function ((&quot;hello world&quot;)) here.

blocks|key|1681524|text|Python版本:+3.8|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1681525|使用守护线程来执行我们想要的，如果我们想终止守护线程，我们所需要做的就是让父线程退出，然后系统会终止父线程创建的守护线程。|1681526|还支持协程和协程函数。|1681527|def+main():
++++start_time+=+time.perf_counter()
++++t1+=+ExitThread(time.sleep,+(10,),+debug=False)
++++t1.start()
++++time.sleep(0.5)
++++t1.exit()
++++try:
++++++++print(t1.result_future.result())
++++except+concurrent.futures.CancelledError:
++++++++pass
++++end_time+=+time.perf_counter()
++++print(f"time+cost+{end_time+-+start_time:0.2f}")|code-block|syntax|javascript|1681528|下面是ExitThread源代码|1681529|import+concurrent.futures
import+threading
import+typing
import+asyncio


class+_WorkItem(object):
++++"""+concurrent\futures\thread.py

++++"""

++++def+__init__(self,+future,+fn,+args,+kwargs,+*,+debug=None):
++++++++self._debug+=+debug
++++++++self.future+=+future
++++++++self.fn+=+fn
++++++++self.args+=+args
++++++++self.kwargs+=+kwargs

++++def+run(self):
++++++++if+self._debug:
++++++++++++print("ExitThread._WorkItem+run")
++++++++if+not+self.future.set_running_or_notify_cancel():
++++++++++++return

++++++++try:
++++++++++++coroutine+=+None
++++++++++++if+asyncio.iscoroutinefunction(self.fn):
++++++++++++++++coroutine+=+self.fn(*self.args,+**self.kwargs)
++++++++++++elif+asyncio.iscoroutine(self.fn):
++++++++++++++++coroutine+=+self.fn
++++++++++++if+coroutine+is+None:
++++++++++++++++result+=+self.fn(*self.args,+**self.kwargs)
++++++++++++else:
++++++++++++++++result+=+asyncio.run(coroutine)
++++++++++++if+self._debug:
++++++++++++++++print("_WorkItem+done")
++++++++except+BaseException+as+exc:
++++++++++++self.future.set_exception(exc)
++++++++++++#+Break+a+reference+cycle+with+the+exception+'exc'
++++++++++++self+=+None
++++++++else:
++++++++++++self.future.set_result(result)


class+ExitThread:
++++"""+Like+a+stoppable+thread

++++Using+coroutine+for+target+then+exit+before+running+may+cause+RuntimeWarning.

++++"""

++++def+__init__(self,+target:+typing.Union[typing.Coroutine,+typing.Callable]+=+None
+++++++++++++++++,+args=(),+kwargs={},+*,+daemon=None,+debug=None):
++++++++#
++++++++self._debug+=+debug
++++++++self._parent_thread+=+threading.Thread(target=self._parent_thread_run,+name="ExitThread_parent_thread"
+++++++++++++++++++++++++++++++++++++++++++++++,+daemon=daemon)
++++++++self._child_daemon_thread+=+None
++++++++self.result_future+=+concurrent.futures.Future()
++++++++self._workItem+=+_WorkItem(self.result_future,+target,+args,+kwargs,+debug=debug)
++++++++self._parent_thread_exit_lock+=+threading.Lock()
++++++++self._parent_thread_exit_lock.acquire()
++++++++self._parent_thread_exit_lock_released+=+False++#+When+done+it+will+be+True
++++++++self._started+=+False
++++++++self._exited+=+False
++++++++self.result_future.add_done_callback(self._release_parent_thread_exit_lock)

++++def+_parent_thread_run(self):
++++++++self._child_daemon_thread+=+threading.Thread(target=self._child_daemon_thread_run
+++++++++++++++++++++++++++++++++++++++++++++++++++++,+name="ExitThread_child_daemon_thread"
+++++++++++++++++++++++++++++++++++++++++++++++++++++,+daemon=True)
++++++++self._child_daemon_thread.start()
++++++++#+Block+manager+thread
++++++++self._parent_thread_exit_lock.acquire()
++++++++self._parent_thread_exit_lock.release()
++++++++if+self._debug:
++++++++++++print("ExitThread._parent_thread_run+exit")

++++def+_release_parent_thread_exit_lock(self,+_future):
++++++++if+self._debug:
++++++++++++print(f"ExitThread._release_parent_thread_exit_lock+{self._parent_thread_exit_lock_released}+{_future}")
++++++++if+not+self._parent_thread_exit_lock_released:
++++++++++++self._parent_thread_exit_lock_released+=+True
++++++++++++self._parent_thread_exit_lock.release()

++++def+_child_daemon_thread_run(self):
++++++++self._workItem.run()

++++def+start(self):
++++++++if+self._debug:
++++++++++++print(f"ExitThread.start+{self._started}")
++++++++if+not+self._started:
++++++++++++self._started+=+True
++++++++++++self._parent_thread.start()

++++def+exit(self):
++++++++if+self._debug:
++++++++++++print(f"ExitThread.exit+exited:+{self._exited}+lock_released:+{self._parent_thread_exit_lock_released}")
++++++++if+self._parent_thread_exit_lock_released:
++++++++++++return
++++++++if+not+self._exited:
++++++++++++self._exited+=+True
++++++++++++if+not+self.result_future.cancel():
++++++++++++++++if+self.result_future.running():
++++++++++++++++++++self.result_future.set_exception(concurrent.futures.CancelledError())|1681530|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Python version: 3.8
Using daemon thread to execute what we wanted, if we want to daemon thread be terminated, all we need is making parent thread exit, then system will terminate daemon thread which parent thread created.
Also support coroutine and coroutine function.
<pre><code>def main():
 start_time = time.perf_counter()
 t1 = ExitThread(time.sleep, (10,), debug=False)
 t1.start()
 time.sleep(0.5)
 t1.exit()
 try:
 print(t1.result_future.result())
 except concurrent.futures.CancelledError:
 pass
 end_time = time.perf_counter()
 print(f&quot;time cost {end_time - start_time:0.2f}&quot;)
</code></pre>
below is ExitThread source code
<pre><code>import concurrent.futures
import threading
import typing
import asyncio


class _WorkItem(object):
 &quot;&quot;&quot; concurrent\futures\thread.py

 &quot;&quot;&quot;

 def __init__(self, future, fn, args, kwargs, *, debug=None):
 self._debug = debug
 self.future = future
 self.fn = fn
 self.args = args
 self.kwargs = kwargs

 def run(self):
 if self._debug:
 print(&quot;ExitThread._WorkItem run&quot;)
 if not self.future.set_running_or_notify_cancel():
 return

 try:
 coroutine = None
 if asyncio.iscoroutinefunction(self.fn):
 coroutine = self.fn(*self.args, **self.kwargs)
 elif asyncio.iscoroutine(self.fn):
 coroutine = self.fn
 if coroutine is None:
 result = self.fn(*self.args, **self.kwargs)
 else:
 result = asyncio.run(coroutine)
 if self._debug:
 print(&quot;_WorkItem done&quot;)
 except BaseException as exc:
 self.future.set_exception(exc)
 # Break a reference cycle with the exception 'exc'
 self = None
 else:
 self.future.set_result(result)


class ExitThread:
 &quot;&quot;&quot; Like a stoppable thread

 Using coroutine for target then exit before running may cause RuntimeWarning.

 &quot;&quot;&quot;

 def __init__(self, target: typing.Union[typing.Coroutine, typing.Callable] = None
 , args=(), kwargs={}, *, daemon=None, debug=None):
 #
 self._debug = debug
 self._parent_thread = threading.Thread(target=self._parent_thread_run, name=&quot;ExitThread_parent_thread&quot;
 , daemon=daemon)
 self._child_daemon_thread = None
 self.result_future = concurrent.futures.Future()
 self._workItem = _WorkItem(self.result_future, target, args, kwargs, debug=debug)
 self._parent_thread_exit_lock = threading.Lock()
 self._parent_thread_exit_lock.acquire()
 self._parent_thread_exit_lock_released = False # When done it will be True
 self._started = False
 self._exited = False
 self.result_future.add_done_callback(self._release_parent_thread_exit_lock)

 def _parent_thread_run(self):
 self._child_daemon_thread = threading.Thread(target=self._child_daemon_thread_run
 , name=&quot;ExitThread_child_daemon_thread&quot;
 , daemon=True)
 self._child_daemon_thread.start()
 # Block manager thread
 self._parent_thread_exit_lock.acquire()
 self._parent_thread_exit_lock.release()
 if self._debug:
 print(&quot;ExitThread._parent_thread_run exit&quot;)

 def _release_parent_thread_exit_lock(self, _future):
 if self._debug:
 print(f&quot;ExitThread._release_parent_thread_exit_lock {self._parent_thread_exit_lock_released} {_future}&quot;)
 if not self._parent_thread_exit_lock_released:
 self._parent_thread_exit_lock_released = True
 self._parent_thread_exit_lock.release()

 def _child_daemon_thread_run(self):
 self._workItem.run()

 def start(self):
 if self._debug:
 print(f&quot;ExitThread.start {self._started}&quot;)
 if not self._started:
 self._started = True
 self._parent_thread.start()

 def exit(self):
 if self._debug:
 print(f&quot;ExitThread.exit exited: {self._exited} lock_released: {self._parent_thread_exit_lock_released}&quot;)
 if self._parent_thread_exit_lock_released:
 return
 if not self._exited:
 self._exited = True
 if not self.result_future.cancel():
 if self.result_future.running():
 self.result_future.set_exception(concurrent.futures.CancelledError())
</code></pre>

blocks|key|1465971|text|假设你想拥有同一个函数的多个线程，这是通过id停止一个线程的最简单的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1465972|import+time
from+threading+import+Thread

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

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|code-block|syntax|javascript|1465973|最棒的是，你可以拥有多个相同和不同的函数，并且可以通过functionname.stop将它们全部停止|offset|length|style|CODE|1465974|如果你想只有一个线程的函数，那么你不需要记住id。如果doit.stop+>+0，就停止。|1465975|entityMap^0|0|0|R|H|0|R|9|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@$I|W|J|X|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Asuming, that you want to have multiple threads of the same function, this is IMHO the easiest implementation to stop one by id:

<pre><code>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
</code></pre>

The nice thing is here, you can have multiple of same and different functions, and stop them all by <code>functionname.stop</code>

If you want to have only one thread of the function then you don't need to remember the id. Just stop, if <code>doit.stop</code> > 0.

blocks|key|1681410|text|正如@Kozyarchuk的answer中所提到的，安装跟踪是可行的。由于此答案不包含任何代码，因此以下是一个可用的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1681411|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|code-block|syntax|javascript|1681412|它在打印1和2后停止。未打印3。|style|CODE|1681413|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/323972/is-there-any-way-to-kill-a-thread/325027#325027^0|E|6|0|0|0|4|1|6|1|E|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]|$A|12|B|13|K|L]|$A|14|B|15|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

As mentioned in @Kozyarchuk's <a href="https://stackoverflow.com/questions/323972/is-there-any-way-to-kill-a-thread/325027#325027">answer</a>, installing trace works. Since this answer contained no code, here is a working ready-to-use example:

<pre><code>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
</code></pre>

It stops after having printed <code>1</code> and <code>2</code>. <code>3</code> is not printed.

blocks|key|1680633|text|这似乎适用于Windows7上的pywin32|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1680634|my_thread+=+threading.Thread()
my_thread.start()
my_thread._Thread__stop()|code-block|syntax|javascript|1680635|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This seems to work with pywin32 on windows 7

<pre><code>my_thread = threading.Thread()
my_thread.start()
my_thread._Thread__stop()
</code></pre>

blocks|key|1465512|text|ØMQ-project的创始人之一Pieter+Hintjens说，使用ÖMQ并避免同步原语，如锁、互斥、事件等，是编写多线程程序最明智和最安全的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1465513|http://zguide.zeromq.org/py:all#Multithreading-with-ZeroMQ|1465514|这包括告诉一个子线程，它应该取消它的工作。这可以通过为线程配备一个ÖMQ套接字，并在该套接字上轮询一条消息来通知它应该取消。|1465515|该链接还提供了一个关于多线程python代码的示例。|1465516|entityMap|0|LINK|mutability|MUTABLE|url|http://zguide.zeromq.org/py:all|1^0|0|3|0|0|0|1M|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|E]]]]

Pieter Hintjens -- one of the founders of the <a href="http://zguide.zeromq.org/py:all" rel="nofollow noreferrer">ØMQ</a>-project -- says, using ØMQ and avoiding synchronization primitives like locks, mutexes, events etc., is the sanest and securest way to write multi-threaded programs:

<a href="http://zguide.zeromq.org/py:all#Multithreading-with-ZeroMQ" rel="nofollow noreferrer">http://zguide.zeromq.org/py:all#Multithreading-with-ZeroMQ</a>

This includes telling a child thread, that it should cancel its work. This would be done by equipping the thread with a ØMQ-socket and polling on that socket for a message saying that it should cancel.

The link also provides an example on multi-threaded python code with ØMQ.

blocks|key|1465262|text|如果您确实需要杀伤子任务的能力，请使用替代实现。multiprocessing和gevent都支持任意杀死一个“线程”。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1465263|Python的线程不支持取消。甚至不要尝试。您的代码很可能会死锁、损坏或泄漏内存，或者产生其他很少发生且不确定的意外的“有趣的”难以调试的效果。|1465264|entityMap^0|O|F|14|6|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

If you really need the ability to kill a sub-task, use an alternate implementation. <code>multiprocessing</code> and <code>gevent</code> both support indiscriminately killing a "thread".

Python's threading does not support cancellation. Do not even try. Your code is very likely to deadlock, corrupt or leak memory, or have other unintended "interesting" hard-to-debug effects which happen rarely and nondeterministically.

blocks|key|1465411|text|您可以在进程中执行命令，然后使用进程id终止它。我需要在两个线程之间进行同步，其中一个线程不会自动返回。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1465412|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;|code-block|syntax|javascript|1465413|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can execute your command in a process and then kill it using the process id.
I needed to sync between two thread one of which doesn’t return by itself.

<pre><code>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;
</code></pre>

blocks|key|1680708|text|使用setDaemon(True)启动子线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1680709|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|code-block|syntax|javascript|1680710|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Start the sub thread with setDaemon(True).

<pre><code>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
</code></pre>

Is it possible to terminate a running thread without setting/checking any flags/semaphores/etc.?

Is there any way to kill a Thread?

Windows

Eclipse

Python

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

问有什么方法可以杀死线程吗？
EN

回答 23

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有什么方法可以杀死线程吗？EN

回答 23

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有什么方法可以杀死线程吗？
EN