您可以在进程中执行命令，然后使用进程id终止它。 我需要在两个线程之间同步，其中一个线程本身不返回。

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;

可以通过在将退出线程的线程中安装trace来终止线程。请参阅所附的链接，了解一种可能的实现。

在Python中杀死一个线程

假设，你想有多个线程的同一个函数，这是IMHO最简单的实现通过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

这里的好处是，你可以有多个相同或不同的函数，并通过functionname。stop来停止它们

如果你想只有一个线程的函数，那么你不需要记住id。如果做了，就停下来。停止> 0。

多处理。进程可以p.terminate()

如果我想杀死一个线程，但不想使用标志/锁/信号/信号量/事件/任何东西，我就把线程提升到完整的进程。对于只使用几个线程的代码，开销并没有那么糟糕。

例如，这可以方便地终止执行阻塞I/O的助手“线程”

转换很简单:在相关代码中替换所有线程。多线程线程。进程和所有队列。多处理队列。排队并将p.t terminate()所需的调用添加到想要杀死子进程p的父进程中

关于多处理，请参阅Python文档。

例子:

import multiprocessing
proc = multiprocessing.Process(target=your_proc_function, args=())
proc.start()
# Terminate the process
proc.terminate()  # sends a SIGTERM

有一个图书馆就是为了这个目的而建的，别说了。尽管这里列出的一些注意事项仍然适用，但至少这个库提供了一种常规的、可重复的技术来实现既定的目标。

另一种方法是使用signal.pthread_kill发送一个停止信号。

from signal import pthread_kill, SIGTSTP
from threading import Thread
from itertools import count
from time import sleep

def target():
    for num in count():
        print(num)
        sleep(1)

thread = Thread(target=target)
thread.start()
sleep(5)
pthread_kill(thread.ident, SIGTSTP)

结果

0
1
2
3
4

[14]+  Stopped