Python-多线程之消费者模式和GIL全局锁

最新推荐文章于 2024-01-16 22:45:42 发布

不止于python

最新推荐文章于 2024-01-16 22:45:42 发布

阅读量121

点赞数

本文链接：https://blog.csdn.net/weixin_42536182/article/details/100971157

版权

一.生产者和消费者模式

　　 什么是生产者消费者模式

　　　　生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，

　　　　所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当

　　　　于一个缓冲区，平衡了生产者和消费者的处理能力。基于队列实现生产者消费者模型

　　定义：

　　　　在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。

　　　　模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

案例：

　　厨师做包子和顾客吃包子问题。

# 一对多 一个大厨对多个顾客

import threading
import queue
import time

q = queue.Queue(maxsize=10)

#生产者
def producer(name):
    count = 1
    while True:
        q.put("包子%d"%count)
        print("生产了包子%d"%count)
        count += 1
        time.sleep(0.8)

#消费者
def consumer(name):
    count = 1
    while True:
        print("[%s]取到了[%s]并且吃了它。。。"%(name,q.get()))
        time.sleep(2)

if __name__ == '__main__':
    p  = threading.Thread(target=producer,args=("刘大厨",))
    a = threading.Thread(target=consumer,args=("A",))
    b = threading.Thread(target=consumer,args=("B",))

    p.start()
    a.start()
    b.start()

# 多对多 多个大厨对多个顾客

import threading
import queue
import time,random
q = queue.Queue(maxsize=10)
count = 1
#生产者
def producer(name):
    global count
    while True:

        # if mutex.acquire():
        #     q.put("包子%d"%count)
        #     print("%s生产了包子%d"%(name,count))
        #     count += 1
        #     time.sleep(random.random()*10)
        #     mutex.release()
        q.put("包子%d" % count)
        print("%s生产了包子%d" % (name, count))
        count += 1
        time.sleep(random.random() * 10)

#消费者
def consumer(name):
    count = 1
    while True:
        print("[%s]取到了[%s]并且吃了它。。。"%(name,q.get()))
        time.sleep(random.random() * 10)

if __name__ == '__main__':

    mutex = threading.Lock()

    p1 = threading.Thread(target=producer,args=("刘大厨",))
    p2 = threading.Thread(target=producer,args=("李大厨",))

    a = threading.Thread(target=consumer,args=("A",))
    b = threading.Thread(target=consumer,args=("B",))
    c = threading.Thread(target=consumer,args=("C",))
    d = threading.Thread(target=consumer,args=("D",))

    p1.start()
    p2.start()
    a.start()
    b.start()
    c.start()
    d.start()

队列：

　　队列的使用，Python的Queue模块中提供了同步的、线程安全的队列类

　　 FIFO（先入先出)队列格式：q = queue.Queue()

　　 LIFO（后入先出）队列格式： q = queue.LifoQueue()

　　 priority 优先级队列格式： q = queue.PriorityQueue()

　　　　向队列中添加数据 q.put(1,'a'), 1代表优先级,越小优先级越高，也可以设置成负数即优先级越小，越先出来

　　这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么就做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

为什么要使用生产者和消费者模式

　　在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，

　　那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了

　　解决这个问题于是引入了生产者和消费者模式。

二.GIL(全局解释器锁)

　　在单线程中数2亿个数和在两个线程中分别数1亿个数，哪个效率更高？速度更快？

　　用事实来证明：

from threading import Thread
from multiprocessing import Process

import time
#计数
def two_hundred_million():
    start_time = time.time()
    i = 0
    for _ in range(200000000):
        i = i + 1
    end_time = time.time()
    print("Total time:{}".format(end_time - start_time))

#数1亿
def one_hundred_million():
    start_time = time.time()
    i = 0
    for _ in range(100000000):
        i = i + 1
    end_time = time.time()
    print("Total time:{}".format(end_time - start_time))

if __name__ == "__main__":
    #单线程---主线程
    #two_hundred_million() #Total time:19.491114616394043

    #多线程
    # for _ in range(2):
    #     t = Thread(target=one_hundred_million) #Total time:18.768073320388794
    #     t.start()                              #Total time:18.906081438064575

    #多进程
    # for _ in range(2):
    #     p = Process(target=one_hundred_million)  #Total time:11.364650011062622
    #     p.start()                                #Total time:11.398651838302612