Part 7.系统编程之线程--3（生产与消费者模式，ThreadLocal对象，异步）

（一）生产与消费者模式

• 什么是⽣产者消费者模式：

⽣产者消费者模式是通过⼀个容器来解决⽣产者和消费者的强耦合问题。

⽣产者和消费者彼此之间不直接通讯，⽽通过阻塞队列来进⾏通讯，所以⽣产 者⽣产完数据之后不⽤等待消费者处理，直接扔给阻塞队列，消费者不找⽣产者要数据，⽽是直接从阻塞队列⾥取，阻塞队列就相当于⼀个缓冲区，平衡了⽣产者和消费者的处理能⼒。

这个阻塞队列就是⽤来给⽣产者和消费者解耦的，纵观⼤多数设计模式，都会找⼀个第三者出来进⾏解耦。

• 为什么要使⽤⽣产者和消费者模式：

在线程世界⾥，⽣产者就是⽣产数据的线程，消费者就是消费数据的线程。

在多线程开发当中，如果⽣产者处理速度很快，⽽消费者处理速度很慢，那 么⽣产者就必须等待消费者处理完，才能继续⽣产数据。同样的道理，如果 消费者的处理能⼒⼤于⽣产者，那么消费者就必须等待⽣产者。

为了解决这 个问题于是引⼊了⽣产者和消费者模式。

实例演示：

import threading
from queue import Queue
import time


class Producer(threading.Thread):
    def run(self):
        count = 0
        while True:
            #如果缓存队列中小于1000个元素，就生产100个,否则就休息
            if queue.qsize() <= 1000:
                for i in range(100):
                    count = count + 1
                    msg = '生成产品' + str(count)
                    print(msg)
                    queue.put(msg)
            time.sleep(0.5)


class Consumer(threading.Thread):
    def run(self):
        while True:
            #如果缓存队列中大于100个元素，就消耗50个，否则休息
            if queue.qsize() >= 100:
                for i in range(50):
                    msg = self.name + '消耗' + queue.get()
                    print(msg)
            time.sleep(1)



if __name__ == "__main__":
    #建立一个缓冲队列
    queue = Queue()

    #初始化队列
    for i in range(100):
        msg = '初始产品' + str(i)
        queue.put(msg)

    #定义两个生产者
    for i in range(2):
        p = Producer()
        p.start()

    #定义五个消费者
    for i in range(5):
        c = Consumer()
        c.start()


》》》输出：
生成产品1
生成产品2
生成产品3
生成产品4
生成产品5生成产品1
生成产品6

生成产品2
生成产品3生成产品7
生成产品8
生成产品4
。。。。。

对于Queue的说明：

1. 对于Queue，在多线程通信之间扮演重要的⻆⾊

2. 添加数据到队列中，使⽤put()⽅法

3. 从队列中取数据，使⽤get()⽅法

4. 判断队列中是否还有数据，使⽤qsize()⽅法

 

（二）ThreadLocal

在多线程环境下，每个线程都有⾃⼰的数据。

⼀个线程使⽤⾃⼰的局部变量⽐使⽤全局变量好，因为局部变量只有线程⾃⼰能看⻅，不会影响其他线程，⽽全局变量的修改必须加锁。

如果要在一个函数中将该函数的局部变量传给另外一个函数，我们可以怎么办呢？可以采用全局字典：

• 全局字典：

⽤⼀个全局dict存放所有的Student对象，然后以thread⾃身作为key获得线程对应的Student对象

import threading

global_dic = {}


def work(name):
    std = Student(name)
    #把std放在全局字典里面，这样即使不同线程同时运行，也不会覆盖掉全局变量的修改
    global_dic[threading.current_thread()] = std
    f1()
    f2()


def f1():
    #不传入std，直接从全局字典中访问即可
    std = global_dic[threading.current_thread()]
    ...


def f2():
    #任何函数都可以直接查看到当前进程的std
    std = global_dic[threading.current_thread()]
    ...

这种⽅式理论上是可⾏的，它最⼤的优点是消除了std对象在每层函数中的传递问题，但是每个函数获取std的代码有点low。 有没有更简单的⽅式？

• 使用ThreadLocal

import threading

#创建全局的TL对象
local_school = threading.local()


def process_student():
    #获取当前线程关联的student
    std = local_school.student
    print('%s (in %s)'%(std, threading.current_thread().name))


def process_thread(name):
    #绑定ThreadLocal的student：
    local_school.student = name
    process_student()


if __name__ == "__main__":
    t1 = threading.Thread(target=process_thread, args=('LaoWang',), name='T-1')
    t2 = threading.Thread(target=process_thread, args=('XiaoWang',), name='T-2')
    t1.start()
    t2.start()
    t1.join()
    t2.join()


》》》输出：
LaoWang (in T-1)
XiaoWang (in T-2)

全局变量local_school就是⼀个ThreadLocal对象，每个Thread对它都可以读写student属性，但互不影响。

你可以把local_school看成全局变量，但每个属性如local_school.student都是线程的局部变量，可以任意读写⽽互不⼲扰，也不⽤管理锁的问题，ThreadLocal内部会处理。

可以理解为全局变量local_school是⼀个dict，不但可以⽤ local_school.student，还可以绑定其他变量，如local_school.teacher等等。

ThreadLocal最常⽤的地⽅就是为每个线程绑定⼀个数据库连接，HTTP请求，⽤户身份信息等，这样⼀个线程的所有调⽤到的处理函数都可以⾮常⽅便地访问这些资源。

 

（三）异步

我们再来看看同步和异步：

• 同步调⽤就是你 喊 你朋友吃饭 ，你朋友在忙 ，你就⼀直在那等，等你朋友忙完了 ，你们⼀起去
• 异步调⽤就是你 喊 你朋友吃饭 ，你朋友说知道了 ，待会忙完去找你 ， 你就去做别的了，等你朋友忙完，你立刻停下手中的工作一起去吃饭。

接下来，我们用一段代码来说明异步的思想：

from multiprocessing import Pool
import time
import os


def test():
    print('---进程池中的进程--pid=%d，ppid=%d'%(os.getpid(),os.getppid()))
    for i in range(3):
        print('--%d--'%i)
        time.sleep(1)
    return 'HAHA'#返回的值将被传入回调函数


def test2(args):
    print('---callback func --pid=%d'%os.getpid())
    print('---callback func --args=%s'%args)


if __name__ == '__main__':
    pool = Pool(3)
    pool.apply_async(func=test, callback=test2)

    while True:
        time.sleep(1)
        print("---主进程-pid=%d---"%os.getpid())


》》》输出：
---进程池中的进程--pid=13368，ppid=18320
--0--
---主进程-pid=18320---
--1--
---主进程-pid=18320---
--2--
---主进程-pid=18320--- 
---callback func --pid=18320
---callback func --args=HAHA
---主进程-pid=18320---
---主进程-pid=18320---
---主进程-pid=18320---
---主进程-pid=18320---
---主进程-pid=18320---