Python学习 Day54 生产者与消费者模式 02

生产者与消费者模式

一、生产者消费者模式概述

生产者与消费者模式是多线程开发中常见的一种模式
1.生产者线程

  • 生产者线程用于“生产”数据

2.消费者线程

  • 消费者线程用于“消费”数据
    Python学习 Day54 生产者与消费者模式 02_第1张图片
import threading
import random
import time
g_money = 0
#创建锁对象
lock = threading.Lock()
class Producer(threading.Thread):
    def run(self):
        global g_money
        for _ in range(10): #_只用来记录次数,所以无需使用迭代变量
            lock.acquire()
            money = random.randint(1000,10000)
            g_money+=money
            print(threading.current_thread().getName(),'挣了{}元,当前余额为:{}'.format(money,g_money))
            time.sleep(1)
            lock.release() #解锁
            
class Customer(threading.Thread):
    def run(self):
        global g_money
        for i in range(10):
            lock.acquire()
            money = random.randint(1000,10000)
            if money <= g_money:
                g_money = money
                print(threading.current_thread().getName(),'花了{}元,当前余额为:{}'.format(money,g_money))
            else:
                print(threading.current_thread().getName(),'想花{}元,但是余额不足,当前余额为:{}'.format(money,g_money))
            time.sleep(1)
            lock.release()
def start():
    for i in range(5):
        th = Producer(name='生产者{0}'.format(i))
        th.start()
    
    for i in range(5):
        cust = Customer(name='------------------消费者{}'.format(i))
        cust.start()

Python学习 Day54 生产者与消费者模式 02_第2张图片


二、Condition版的生产者消费者模式

Condition版的生产者与消费者模式

函数 描述
acquire() 上锁
release() 解锁
wait() 将当前线程处于等待状态,并且会释放锁。可以被其他线程使用notify()和noti_all()函数唤醒。被唤醒后继续等待上锁,上锁后继续执行下面的代码
notify() 通知某个正等待的线程,默认是第一个等待的线程
notify_all() 通知所有正在等待的线程。notify()和notif_all()需要在release()之前调用

为什么要使用Condition版的生产者与消费者模式?

  • 因为当生产者生产次数使用完后,而当前的余额又不足以支撑消费者的使用,但程序仍然会输出“消费者n想使用资源,但资源不够”的冗余信息,实际上降低了程序运行的效率

如下所示
Python学习 Day54 生产者与消费者模式 02_第3张图片
Condition版的生产者与消费者模式

  • 当生产者生产次数用完,消费者想消耗资源而资源不足时,即刻停止程序,节约程序运行时间
import threading
import random
import time
g_money = 0
#创建Condition对象
g_time = 0
lock = threading.Condition()
class Producer(threading.Thread):
    def run(self):
        global g_money
        global g_time
        for _ in range(10): #_只用来记录次数,所以无需使用迭代变量
            lock.acquire()
            money = random.randint(1000,10000)
            g_money+=money
            g_time+=1
            print(threading.current_thread().getName(),'挣了{}元,当前余额为:{}'.format(money,g_money))
            #time.sleep(1)
            lock.notify_all() #唤醒所有等待的线程
            lock.release() #解锁

class Customer(threading.Thread):
    def run(self):
        global g_money
        for i in range(10):
            lock.acquire() #上锁
            money = random.randint(1000,10000) #消费的金额
            while g_money < money:
                if g_time >= 50:
                    lock.release()
                    return
                print(threading.current_thread().getName(),'想花{}元,但是余额不足,当前余额为:{}'.format(money,g_money))
                lock.wait() #余额不足的情况下需要等待生产者生产
            g_money-=money #余额充足的情况下开始消费
            print(threading.current_thread().getName(),'--------------花了{}元,当前余额为:{}'.format(money,g_money))

            #time.sleep(1)
            lock.release()
def start():
    for i in range(5):
        th = Producer(name='生产者{0}'.format(i))
        th.start()

    for i in range(5):
        cust = Customer(name='------------------消费者{}'.format(i))
        cust.start()

if __name__ == '__main__':
    start()

Python学习 Day54 生产者与消费者模式 02_第4张图片

你可能感兴趣的:(Python爬虫)