我对这个游戏已经很晚了，但我一直在与一个类似的问题作斗争，下面的内容似乎为我完美地解决了这个问题，并且让我在守护子线程退出时做一些基本的线程状态检查和清理:

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]

没有官方API来做这个，没有。

你需要使用平台API来杀死线程，例如pthread_kill或TerminateThread。你可以访问这样的API，例如通过pythonwin，或通过ctypes。

注意，这本质上是不安全的。这可能会导致不可收集的垃圾(来自堆栈帧的局部变量，成为垃圾)，并可能导致死锁，如果被杀死的线程在被杀死时具有GIL。

如果您显式地调用time.sleep()作为线程的一部分(比如轮询一些外部服务)，对Phillipe方法的改进是在sleep()的任何地方使用事件的wait()方法中的超时。

例如:

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

然后运行它

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

使用wait()而不是sleep()ing和定期检查事件的优点是，您可以在更长的睡眠间隔中编程，线程几乎立即停止(否则您将处于sleep()ing)，并且在我看来，处理退出的代码明显更简单。

这是一个糟糕的答案，请看评论

以下是如何做到这一点:

from threading import *

...

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

给它几秒钟，然后你的线程应该停止。还要检查thread._Thread__delete()方法。

为了方便，我建议使用thread.quit()方法。例如，如果你的线程中有一个套接字，我建议在你的套接字句柄类中创建一个quit()方法，终止套接字，然后在你的quit()中运行一个thread. _thread__stop()。

Pieter Hintjens (ØMQ-project的创始人之一)表示，使用ØMQ并避免使用锁、互斥对象、事件等同步原语，是编写多线程程序最明智、最安全的方法:

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

这包括告诉子线程，它应该取消它的工作。这可以通过为线程配备ØMQ-socket并轮询该套接字以获得一条表示它应该取消的消息来实现。

该链接还提供了一个使用ØMQ的多线程python代码示例。

最简单的方法是:

from threading import Thread
from time import sleep

def do_something():
    global thread_work
    while thread_work:
        print('doing something')
        sleep(5)
    print('Thread stopped')

thread_work = True
Thread(target=do_something).start()
sleep(5)
thread_work = False