本文详细介绍了Python中多线程编程中如何避免僵尸进程和数据丢失，重点讲解了如何通过全局变量和threading.Event对象来优雅地终止线程。包括线程的默认关闭方式、耗时任务的优雅退出策略以及Event对象的工作原理和使用示例。 摘要由CSDN通过智能技术生成

关于python多线程编程知识，请参阅 由浅入深掌握Python多线程编程

Threading 模块的 Thread 类并没有提供关闭线程的方法。如果不正确关闭子线程，可能遇到如下问题：

• 中止主线程后，子线程仍然在运行，成为僵尸进程
• 子线程打开的文件未能正确关闭，造成数据丢失
• 子线程打开的数据库，未能提交更新，造成数据丢失

那么应该如何正确关闭线程呢？

1. Python 默认关闭线程的方式

线程对象创建后，调用start(方法运行， 执行结束后，自动关闭。如下面的示例代码：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import threading    #导入threading 模块
import time
# 定义任务函数 print_time
def print_time ( threadName ,delay ):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s: %s \n" % (threadName,time.ctime(time.time())))
# 定义任务函数 print_cube
def print_cube(num):
    #pring cube
    print("Cube:{} \n".format(num*num*num))
# 创建两个线程
if __name__ == "__main__":
        # 创建两个子线程
        t1 = threading.Thread( target=print_cube,args=(10,))
        t2 = threading.Thread( target=print_time,args=("Thread-2",4,))
        #start threads
        t1.start()   # start 后，子线程开始运行
        t2.start()
        t1.join()     #join 命令：让主线程暂停运行，等待子线程运行结束。
        t2.join()
        print("Done") # The statement is executed after sub threads done
2. 如何优雅地关闭线程？
 
上节的例子，线程执行时间短，很快可以结束，所以主线程可以等待其结束。但是如果子线程执行的是1个耗时任务，如提供1个服务，或执行1个Monitor 任务，子线程内可能存在永久循环，这时子线程对象运行start()后，就一直处理运行状态。
 
在WIndows系统，如果应用程序直接退出，子线程自然也被强行中止，但子线程正在执行的任务可能会受影响，如正在存取的文件可能正确关闭，造成数据丢失等。
 在Linux系统，如果应用程序直接退出，如使用kill命令杀死进程，未正确关闭的子线程可能仍在运行，成为僵尸进程。
 
那么如何优雅地停止子线程呢？思路有两个：
 1） 通过设置全局状态变量来关闭线程
 2） 通过 threading.Event 对象来关闭线程
 
下面示例展示两种方法的实现过程
 
2.1. 使用全局变量来关闭线程
 
实现步骤：
 
在线程内添加状态变量
线程循环体内，检测状态变量，如果为False ，退出循环。
主线程需要关闭线程时，将子线程对象的状态变量置为False即可。
 
2.1.1 关闭 thread类实现的线程
 
class CountdownTask:
    def __init__(self):
          self._running = True   # 定义线程状态变量
	def terminate(self):
	    self._running = False 
	def run(self, n):
	    # run方法的主循环条件加入对状态变量的判断
	    while self._running and n > 0:
	        print('T-minus', n)
	        n -= 1
	        time.sleep(5)
	    print("thread is ended") 
c = CountdownTask()
th = Thread(target = c.run, args =(10, ))
th.start()
# 对于耗时线程，没必要再用join()方法了，注意主线程通常也需要有个监控循环
# … any code … 
# Signal termination
q = input("please press any key to quit ")
c.terminate() 
2.1.2 关闭函数式线程
 
关闭函数式线程，可以用全局变量做状态变量
 
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')
2.2. 使用 threading.Event 对象关闭子线程
 
2.2.1 Event 机制工作原理
 
Event 是线程间通信的一种方式。其作用相当于1个全局flag，主线程通过控制 event 对象状态，来协调子线程步调。
 
主线程创建 event 对象，并将其做为参数传给子线程
主线程可以用set()方法将event 对象置为true, 用clear()方法将其置为false。
子线程循环体内，检查 event 对象的值，如果为 True, 则退出循环。
子线程，可使用 event.wait() 将阻塞当前子进程，直至event 对象被置为true.
 
event 类的常用方法
 
set() 设置 True
clear() 设置 False,
wait() 使进程等待，直到flag被改为true.
is_set() 查询 event 对象，如被设置为真，则返回True, 否则返回False.
 
if event.is_set():
     # do something before end worker 
     break
这种方式的优点是，Event对象是线程安全的，而且速度更快，推荐使用这种方式关闭耗时线程。
 
2.2.2 完整代码：
 
from time import sleep
from threading import Thread
from threading import Event
# define task function
def task(event):
    # execute a task in a loop
    for i in range(100):
        # block for a moment
        sleep(1)
        # check for stop
        if event.is_set():
            # 在此添加退出前要做的工作，如保存文件等
            break
        # report a message
        print('Worker thread running...')
    print('Worker is ended')
# create the event
event = Event()
# create a thread 
thread = Thread(target=task, args=(event,))
# start the new thread
thread.start()
# block for a while
sleep(3)
# stop the worker thread
print('Main stopping thread')
event.set()
# 这里是为了演示，实际开发时，主进程有事件循环，耗时函数不需要调用join()方法
thread.join()
子线程执行其任务循环，它每次循环都会检查event对象，该对象保持 false，就不会触发线程停止。
 
当主线程调用event对象的 set() 方法后，在子线程循环体内，调用event对象is_set()方法，发现event 对象为True后, 立即退出任务循环，结束运行。
 
延伸阅读： python多线程编程: 如何暴力但不失优雅地关闭线程  
                    可以从以下几方面检查 ：
1） Numba加速的函数，输入必须是ndarray类型或者python array, list，int等类型。 
2） 不要在函数体内直接修改输入变量，复制到1个新对象后再修改并返回，
3） 可尝试将输出保存为MP4 文件，如果正常，则不是Numba加速造成。  
4）OpenCV 的wait() 使用不当可能会有马赛克，可以尝试将时间改长一些。
                用Numba加速OpenCV Python视频处理代码,提升6.5倍性能
                    努力的程序狒狒: 
                    up主 为啥摄像头画面变成了马赛克式的？
                Python使用Cython实例，速度提升150倍以上
                    __弯弓__: 
                    对于大多数项目，python庞大的生态以及高开发效率， 选择Python肯定要比用C++明智。至于python性能优化，文中也提到过，通常只需要把个别耗CPU的函数或代码块用Cython稍微修改一下就可以了。此外Cython语法与C基本相同，而且内存是自动回收，
                消除Python OpenCV显示摄像头画面的延迟
                    m0_64022196: 
                    time.sleep不能模拟真实的耗时啊，sleep阻塞了主线程让你的接收线程可以接收，但实际上算法处理的耗时并不会阻塞主线程，还是会卡住接收的