python - sys.exit(0) 是在 python 中退出/杀死线程的有效方法吗？

Question

我正在用python编写一个计时器。当计时器到达0时，我希望我创建的线程自动退出。

class Rollgame:
    timer = 0
    def timerf(self, timer):
        self.timer = timer
        while self.timer > 0:
            time.sleep(0.1)
            self.timer -= 0.1
        sys.exit(0)

这是退出线程的有效方法吗？它似乎在我正在构建的程序的上下文中工作，但是我不确定这是否是一个好方法。
如果我选择在诸如 flask /django 应用程序之类的东西中实现它，这仍然有效吗？
抱歉，如果这个问题看起来很愚蠢或太简单，我以前从未在 python 中使用过线程。

Answer 1

通常，突然终止线程被认为是一种不好的编程习惯。突然终止线程可能会使必须正确关闭的关键资源处于打开状态。但是一旦某个特定的时间段过去或产生了一些中断，您可能想终止一个线程。有多种方法可以杀死 python 中的线程。
设置/重置停止标志:
为了杀死一个线程，我们可以声明一个停止标志，这个标志会被线程偶尔检查。例如:

# Python program showing 
# how to kill threads 
# using set/reset stop 
# flag 

import threading 
import time 

def run(): 
    while True: 
        print('thread running') 
        global stop_threads 
        if stop_threads: 
            break

stop_threads = False
t1 = threading.Thread(target = run) 
t1.start() 
time.sleep(1) 
stop_threads = True
t1.join() 
print('thread killed') 

在上面的代码中，只要设置了全局变量 stop_threads，目标函数 run() 就结束了，线程 t1 可以通过使用 t1.join() 来杀死。但是由于某些原因，人们可能会避免使用全局变量。对于这些情况，可以传递函数对象以提供类似的功能，如下所示:

# Python program killing 
# threads using stop 
# flag 

import threading 
import time 

def run(stop): 
    while True: 
        print('thread running') 
        if stop(): 
                break
                
def main(): 
        stop_threads = False
        t1 = threading.Thread(target = run, args =(lambda : stop_threads, )) 
        t1.start() 
        time.sleep(1) 
        stop_threads = True
        t1.join() 
        print('thread killed') 
main() 

使用跟踪杀死线程:
此方法通过在每个线程中安装跟踪来工作。每个跟踪都会在检测到某些刺激或标志时自行终止，从而立即终止相关线程。例如:

# Python program using 
# traces to kill threads 

import sys 
import trace 
import threading 
import time 
class thread_with_trace(threading.Thread): 
def __init__(self, *args, **keywords): 
    threading.Thread.__init__(self, *args, **keywords) 
    self.killed = False

def start(self): 
    self.__run_backup = self.run 
    self.run = self.__run    
    threading.Thread.start(self) 

def __run(self): 
    sys.settrace(self.globaltrace) 
    self.__run_backup() 
    self.run = self.__run_backup 

def globaltrace(self, frame, event, arg): 
    if event == 'call': 
    return self.localtrace 
    else: 
    return None

def localtrace(self, frame, event, arg): 
    if self.killed: 
    if event == 'line': 
        raise SystemExit() 
    return self.localtrace 

def kill(self): 
    self.killed = True

def func(): 
while True: 
    print('thread running') 

t1 = thread_with_trace(target = func) 
t1.start() 
time.sleep(2) 
t1.kill() 
t1.join() 
if not t1.isAlive(): 
print('thread killed')

在此代码中，start() 稍作修改，以使用 settrace() 设置系统跟踪功能。本地跟踪函数被定义为，只要设置了相应线程的终止标志(已终止)，就会在执行下一行代码时引发 SystemExit 异常，从而结束目标函数 func 的执行。现在可以使用 join() 终止线程。
最后，使用多处理模块杀死线程 :
Python 的 multiprocessing 模块允许您以与使用 threading 模块产生线程类似的方式产生进程。多线程模块的接口(interface)与线程模块的接口(interface)类似。例如，在给定的代码中，我们创建了三个从 1 到 9 的线程(进程)。现在，假设我们想要终止所有线程。您可以使用多处理来做到这一点。

# Python program killing 
# a thread using multiprocessing 
# module 

import multiprocessing 
import time 

def func(number): 
    for i in range(1, 10): 
        time.sleep(0.01) 
        print('Processing ' + str(number) + ': prints ' + str(number*i)) 

# list of all processes, so that they can be killed afterwards 
all_processes = [] 

for i in range(0, 3): 
    process = multiprocessing.Process(target=func, args=(i,)) 
    process.start() 
    all_processes.append(process) 

# kill all processes after 0.03s 
time.sleep(0.03) 
for process in all_processes: 
    process.terminate() 

总而言之，有很多方法可以终止线程，但我个人不会使用 sys.exit()。