文章目录

  • 生产者与消费者模型
  • 一、 多线程和队列模块
  • 二、 多进程和队列模块
  • 三、 协程
  • 1、 基本
  • 2、 greenlet
  • 3、 grevent和队列


生产者与消费者模型

一、 多线程和队列模块

import threading, queue  # 多线程模块和队列模块

que = queue.Queue()  # 创建队列


# 建立消费者模型类
class Consumer(threading.Thread):  # 继承线程列使用

    def __init__(self, que):  # 参数传入队列对象
        super(Consumer, self).__init__()  # 继承祖宗类的初始化方法使用
        self.que = que  # 自定义队列对象属性
        self.start()  # 自动启动线程

    def run(self):  # 线程自带的方法，运行时会自动调用
        # 消费者逻辑，不考虑生产者，只需要从队列里面不断获取任务
        while True:
            # 获取队列任务
            item = self.que.get()
            print(f"消费者消费了{item}")


# 建立生产者模型类
class Producer(threading.Thread):

    def __init__(self, que):  # 参数传入队列对象
        super(Producer, self).__init__()  # 继承祖宗类的初始化方法使用
        self.que = que  # 自定义队列对象属性
        self.start()

    def run(self):  # run方法线程自带的方法 运行时会自动调用
        # 生产者逻辑，不考虑消费者，只需要不断生产任务
        import random, time
        while True:
            time.sleep(1)
            item = random.randint(1, 100)
            print(f"生产了{item}")
            # 生产任务
            self.que.put(item)


# 实例化线程对象
con = Consumer(que)
pro = Producer(que)

二、 多进程和队列模块

import multiprocessing  # 多进程模块

que = multiprocessing.Queue()  # 创建队列


# 建立消费者模型类
class Consumer(multiprocessing.Process):  # 继承进程列使用

    def __init__(self, que):  # 参数传入队列对象
        super(Consumer, self).__init__()  # 继承祖宗类的初始化方法使用
        self.que = que  # 自定义队列对象属性
        self.start()  # 自动启动进程

    def run(self):  # 进程自带的方法，运行时会自动调用
        # 消费者逻辑，不考虑生产者，只需要从队列里面不断获取任务
        while True:
            # 获取队列任务
            item = self.que.get()
            print(f"消费者消费了{item}")


# 建立生产者模型类
class Producer(multiprocessing.Process):

    def __init__(self, que):  # 参数传入队列对象
        super(Producer, self).__init__()  # 继承祖宗类的初始化方法使用
        self.que = que  # 自定义队列对象属性
        self.start()

    def run(self):  # run方法进程自带的方法 运行时会自动调用
        # 生产者逻辑，不考虑消费者，只需要不断生产任务
        import random, time
        while True:
            time.sleep(1)
            item = random.randint(1, 100)
            print(f"生产了{item}")
            self.que.put(item)


if __name__ == '__main__':
    # 实例化进程对象
    con = Consumer(que)
    pro = Producer(que)

三、 协程

1、 基本

import time


# 定义消费者模型
def consumer():
    while True:
        y = yield
        time.sleep(1)  # 一秒后处理数据
        print("处理了数据", y)


# 定义生产者模型
def producer():
    con = consumer()  # 拿到消费者对象，并且激活使用
    next(con)
    for i in range(10):
        time.sleep(1)
        print("发送数据", i)
        con.send(i)


producer()  # 直接调用生产者模型

2、 greenlet

import time
from greenlet import greenlet  # 导入greenlet模块


# 定义消费者模型
def consumer():
    while True:
        var = pro.switch()  # 切换任务到生产者，进入等待，接收数据
        print("consume:", var)


# 定义生产者模型
def producer():
    for i in range(10):
        time.sleep(1)
        print("produce:", i)
        con.switch(i)  # 给yield传递值
        print(f"{i}生产消费完成")


# 让我们的greenlet模块来做我们的协程任务
con = greenlet(consumer)
pro = greenlet(producer)  # 生产者

# greenlet模块通过switch方法来切换任务，switch内五参数时会切换任务，并且处于等待接收数据的状态，有参数的情况下，会将参数作为数据发送到无参数的switch里面
con.switch()

3、 grevent和队列

# 第三方模块需要下载：pip install gevent
# 猴子补丁
from gevent import monkey;monkey.patch_all()  # 使用gevent模块时需要加上猴子补丁
import gevent  # 协程模块
from gevent.queue import Queue  # gevent自带的队列模块

que = Queue(3)


# 生产者模型
def producer():
    for i in range(20):
        print("produce:", i)
        que.put(i)


# 消费者模型
def consumer():
    for i in range(20):
        var = que.get()
        print("consume:", var)


# 由gevent模块来做我们的协程任务
pro = gevent.spawn(producer, que)
con = gevent.spawn(consumer, que)
# 等待所有协程执行完毕
gevent.joinall([pro, con])