前言

前面的subprocess库主要讲解的是进程知识与进程间的交互。而进程有可以拥有多个线程，所以threading库提供了管理多个线程执行的API，允许程序在同一个进程空间并发地运行多个操作。

本篇，将详细的介绍Python线程库：threading。

Thread对象

要使用threading库，最简单的方式是使用Thread，它可以直接通过函数实例化一个Thread对象，并调用start让它工作。毕竟，我们用线程也是为了执行耗时任务，把任务封装到一个函数中，直接创建往往最简单。

示例如下：

import threading

def print1tonum(num):
    for i in range(10000):
        print(i)

t = threading.Thread(target=print1tonum,args=(10000,))
t.start()

运行之后，效果如下：

这里，我们创建了一个线程，并向它传递参数告诉它要完成什么工作。

区分线程

一般来说，我们创建线程是避免在主线程中处理耗时的任务，但是有时候，就算是基本的运算任务，因为其叠加起来非常的多，我们会考虑用多个线程进行处理。示例如下：

import threading
import time

def printThreadName1():
    print(threading.current_thread().getName() + " start")
    time.sleep(0.2)
    print(threading.current_thread().getName() + ' end')

def printThreadName2():
    print(threading.current_thread().getName() + " start")
    time.sleep(0.2)
    print(threading.current_thread().getName() + ' end')

def printThreadName3():
    print(threading.current_thread().getName() + " start")
    time.sleep(0.2)
    print(threading.current_thread().getName() + ' end')

t1 = threading.Thread(name='t1', target=printThreadName1)
t2 = threading.Thread(name='t2', target=printThreadName2)
t3 = threading.Thread(name='t3', target=printThreadName3)
t1.start()
t2.start()
t3.start()

运行之后，效果如下：

这里，我们会发现print打印非常的混乱，虽然3个线程都是一摸一样的，但结束的时候并不是按顺序结束的，因为它们是同时运行的。（这里需要注意，更多内容接着往下看）

守护线程

运行上面的代码我们会发现，主程序都是在等线程运行完成之后，才结束的。也就是说，创建线程的主程序，无法在线程结束前安全退出。那么，可不可保证运行线程时，主线程可以退出呢？

答案是可以的，这个时候我们需要用到守护线程，这个线程可以一直运行而不阻塞主程序的退出，比如在服务器监控的工具线程，对于这些服务，守护线程往往更有用。

要构造守护线程，需要将上面创建线程的方式增加一个参数daemon，它是一个布尔值，默认值为False，普通线程，改为True就是守护线程。

import threading
import time

def printThreadName1():
    print(threading.current_thread().getName() + " start")
    time.sleep(0.2)
    print(threading.current_thread().getName() + ' end')

def printThreadName2():
    print(threading.current_thread().getName() + " start")
    time.sleep(0.2)
    print(threading.current_thread().getName() + ' end')

def printThreadName3():
    print(threading.current_thread().getName() + " start")
    time.sleep(0.2)
    print(threading.current_thread().getName() + ' end')

t1 = threading.Thread(name='t1', target=printThreadName1, daemon=True)
t2 = threading.Thread(name='t2', target=printThreadName2)
t3 = threading.Thread(name='t3', target=printThreadName3)
t1.start()
t2.start()
t3.start()

运行之后，效果如下：

可以看到，博主这里将t1设置为守护线程，但是没有看到t1结束主程序就结束了。如果需要等待一个守护线程完成工作，可以增加join()函数。

t1 = threading.Thread(name='t1', target=printThreadName1, daemon=True)
t2 = threading.Thread(name='t2', target=printThreadName2, daemon=True)
t3 = threading.Thread(name='t3', target=printThreadName3, daemon=True)
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()

输出结果就不展示了，与前文非守护的线程一样。

需要注意的是，join()函数会无限阻塞，直到线程任务结束。当然，如果想设置一个最大的等待时间，超过时间就不在等待也行。

示例如下：

t1 = threading.Thread(name='t1', target=printThreadName1, daemon=True)
t2 = threading.Thread(name='t2', target=printThreadName2, daemon=True)
t3 = threading.Thread(name='t3', target=printThreadName3, daemon=True)
t1.start()
t2.start()
t3.start()
t1.join(0.4)
print(t1.is_alive())
t2.join()
t3.join()

这里，设置了t1等待最长时间为0.4秒，读者可以将t1线程的运行时间增加到1秒，看看其效果，is_alive()的意义是等待了0.4秒后，t1是否还在运行，为True代表是的，如下所示：

需要注意的是join()可能会造成死锁。比如现在有3个线程t1，t2，t3，t1需要使用资源12，t2需要使用资源23，t3需要使用资源13，3个同时运行。开始时，t1在使用资源1等待资源2，t2在使用资源2等待资源3，t3在使用资源3等待资源1，它们互相等待对方释放资源，但都不释放，导致循环等待下去，形成死锁。（与主线程等待线程结束差不多的道理）

自定义线程

从上面的所有线程运行，想必读者肯定发现了一个问题，那就是threading.Thread无法提供返回值。而实际的多线程运行中，往往我们都是获取网络数据，然后再处理，所以必须获取其处理的结果。

这个时候，自定义线程就能实现该需求，示例如下：

import threading
import requests

class GetHTMLThread(threading.Thread):
    def __init__(self, args, kwargs):
        super(GetHTMLThread, self).__init__()
        self.args = args
        self.kwargs = kwargs

    def run(self):
        print(self.args)
        self.result = requests.get(url=self.kwargs['url'])

    def get_result(self):
        return self.result.text

t = GetHTMLThread(args=(1,), kwargs={'url': "https://www.baidu.com"})
t.start()
t.join()
print(t.get_result())

运行之后，效果如下：

定时器线程

在我们使用django搭建服务器时，往往有许多的延时触发任务。比如我们CSDN就是我们搭建的博客网站，那么我们定时更新博客就是一个延时任务，我昨天写完博客，希望明天下午18点发送，那么这个延时任务就是中间的时差。

那么，此时我们使用定时器线程往往效果更好。示例如下：

import threading

def getWeather():
    print("更新博客")

t1 = threading.Timer(0.3, getWeather)
t1.setName('t1')
t2 = threading.Timer(0.3, getWeather)
t2.setName('t2')

t1.start()
t2.start()
t2.cancel()

运行之后，效果如下：

这里会延迟0.3秒执行线程，而之所以t2线程没有执行，是因为我们调用了cancel()函数，取消了该线程的执行。

线程间传送信号

尽管使用多线程的目的是并发地运行单独的任务，但有时候也需要在多个线程间同步操作。而Python中，线程的通信方法是事件对象。

Event管理一个内部标志，调用者可以用set()和clear()方法控制这个标志。其他线程可以使用wait()暂停，直到这个标志被设置，可以有效的阻塞进程直到允许这些线程继续。

import threading
import time

def wait_for_event(e):
    print("wait_for_event")
    event_is_set = e.wait()
    print("wait_for_event", event_is_set)

def wait_for_event_timeout(e, t):
    while not e.is_set():
        print("wait_for_event_timeout")
        event_is_set = e.wait(t)
        print("wait_for_event_timeout", event_is_set)
        if event_is_set:
            print("运行任务")
        else:
            print('运行其他任务')

e = threading.Event()
t1 = threading.Thread(
    name='t1',
    target=wait_for_event,
    args=(e,)
)
t1.start()
t2 = threading.Thread(
    name='t2',
    target=wait_for_event_timeout,
    args=(e, 2)
)
t2.start()
time.sleep(5)
e.set()

运行之后，效果如下：