python多线程 - 线程间通信（全局变量、queue）

简介

什么是线程间通信呢？

多个线程处理同一资源，但是任务不同

为什么要通信？

如果各个线程之间各干各的，确实不需要通信，这样的代码也十分的简单。但这一般是不可能的，至少线程要和主
线程进行通信，不然计算结果等内容无法取回。而实际情况中要复杂的多，多个线程间需要交换数据，才能得到正确的执行结果。

1、共享变量（全局变量）

线程间通过共享同一个全局变量进程通讯

最简单的想法是建立一个全局变量。几个子线程共同操作这个全局变量(几个线程写变量，几个线程读变量）

举爬虫的例子，假设需要爬取博客网站的所有文章详情，先要通过文章列表页爬取所有文章的url，再根据文章的url，爬取文章的具体内容。一般来说，爬取文章的url速度比较快，因为文章内容数据量相对更大，速度要慢一些，所以可以用一个 线程A 爬取文章url列表，多个线程 B 根据url访问文章具体内容并爬取。此时两个线程之间有交互，文章内容爬取线程B需要得到文章列表爬取线程A的具体数据，而线程A(文章列表爬取)无需线程B(文章内容爬取)的数据。

import threading # 导入线程包
import time

detail_url_list = []
# 爬取文章详情页
def get_detail_html(detail_url_list, id):
    while True:
        if len(detail_url_list)==0: # 列表中为空，则等待另一个线程放入数据
            continue
        url = detail_url_list.pop()
        time.sleep(2)  # 延时2s，模拟网络请求
        print("thread {id}: get {url} detail finished".format(id=id,url=url))

# 爬取文章列表页
def get_detail_url(detail_url_list):
    for i in range(10000):
        time.sleep(1) # 延时1s，模拟比爬取文章详情要快
        detail_url_list.append("http://projectedu.com/{id}".format(id=i))
        print("get detail url {id} end".format(id=i))

if __name__ == "__main__":
    # 创建读取列表页的线程
    thread = threading.Thread(target=get_detail_url, args=(detail_url_list,))
    # 创建读取详情页的线程
    html_thread= []
    for i in range(4):
        thread2 = threading.Thread(target=get_detail_html, args=(detail_url_list,i))
        html_thread.append(thread2)
    start_time = time.time()
    # 启动两个线程
    thread.start()
    for i in range(4):
        html_thread[i].start()
    # 等待所有线程结束
    thread.join()
    for i in range(4):
        html_thread[i].join()

    print("last time: {} s".format(time.time()-start_time))

看起来结果很完美，但是，存在着一定的隐患，虽然一般很慢暴露出来。

有两个问题：

python中的List不是线程安全的，可能pop()函数执行到了一半，另一个线程同时执行pop()，或者另一个线程执行append()，这个时候detail_url_list中的数据就会发生错误，导致程序挂掉或者得到不正确的结果。
假设detail_url_list中只有一个元素，当一个线程判断列表不为空，还没有pop()出数据时，时间片被另一个线程抢走，同样列表中还有元素，同样不为空，成功的把数据取出来，这时列表就为空了，这时时间片又让给了上一个线程，上一个线程执行pop()，导致pop from empty list的异常！在url = detail_url_list.pop()语句前加上time.sleep(1)可以暴露出这个问题。

因为多个线程是共享进程的空间的，所以线程之间的通信比较简单，主要是利用全局变量的方法。全局变量对进程内的的所有线程都是可见的，所以多个线程可以通过操作全局变量达到相互通信的效果。但是这也存在一个问题，就是“资源”的竞争。

这里所说的资源指的就是全局变量，正是因为这种竞争(因为多线程是同时运行的，而我们往往不会去控制线程运行的顺序，不然也不会用多线程了)，导致可一些我们不愿见到的结果，所以我们每个线程对全局变量的操作都希望是原子性的。

为了解决这个问题在线程见引入了三种同步互斥机制，分别是信号量，互斥锁，条件变量。

2、通过消息队列--queue模块

使用消息队列的过程和上面一样，只不过queue进行了很好的封装，在放值和取值的时候时线程安全的。

queue模块实现了多生产者，多消费者的队列。当要求信息必须在多线程间安全交换，这个模块在线程编程时非常有用。里面主要实现了3中队列。

class queue.Queue(maxsize = 0): 构造一个FIFO队列，maxsize可以限制队列的大小。如果队列的大小达到了队列的上限，就会加锁，加入就会阻塞，直到队列的内容被消费掉。maxsize的值小于等于0，那么队列的尺寸就是无限制的
class queue.LifoQueue(maxsize = 0): 构造一个LIFO（Last In First Out）队列
class PriorityQueue(maxsize = 0)：优先级最低的先出去，优先级最低的一般使用sorted(list(entries))[0]。典型加入的元素是一个元祖(优先级, 数据)

使用queue重写之前的代码：

import threading # 导入线程包
from queue import Queue
import time

# 爬取文章详情页
def get_detail_html(detail_url_list, id):
    while True:
        url = detail_url_list.get()
        time.sleep(2)  # 延时2s，模拟网络请求
        print("thread {id}: get {url} detail finished".format(id=id,url=url))

# 爬取文章列表页
def get_detail_url(queue):
    for i in range(10000):
        time.sleep(1) # 延时1s，模拟比爬取文章详情要快
        queue.put("http://projectedu.com/{id}".format(id=i))
        print("get detail url {id} end".format(id=i))

if __name__ == "__main__":
    detail_url_queue = Queue(maxsize=1000)
    # 先创造两个线程
    thread = threading.Thread(target=get_detail_url, args=(detail_url_queue,))
    html_thread= []
    for i in range(3):
        thread2 = threading.Thread(target=get_detail_html, args=(detail_url_queue,i))
        html_thread.append(thread2)
    start_time = time.time()
    # 启动两个线程
    thread.start()
    for i in range(3):
        html_thread[i].start()
    # 等待所有线程结束
    thread.join()
    for i in range(3):
        html_thread[i].join()

    print("last time: {} s".format(time.time()-start_time))

总结

线程间需要通信，使用全局变量需要加锁。
使用queue模块，可在线程间进行通信，并保证了线程安全。