python多线程编程：如何优雅地关闭线程

在并发编程中，我们可能会创建新线程，并在其中运行任务，可能由于一些原因，决定停止该线程。例如：

• 不再需要线程任务的结果了。
• 应用程序正在关闭。
• 线程执行可能已经出现了异常

关于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 对象状态，来协调子线程步调。

使用方式

1. 主线程创建 event 对象，并将其做为参数传给子线程
2. 主线程可以用set()方法将event 对象置为true, 用clear()方法将其置为false。
3. 子线程循环体内，检查 event 对象的值，如果为 True, 则退出循环。
4. 子线程，可使用 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多线程编程: 如何暴力但不失优雅地关闭线程