Python多线程Thread——生产者消费者模型

import random
import threading
import time

Lock = threading.Lock()

books = 10  # 图书馆书籍数量
b_rt = 0    # 外面持有数量(借出去的数量)


def ba():
    global books
    books += 1
    print("进书1本")
    t = threading.Timer(10, ba) 
    t.start()


def rent():
    global b_rt
    global books
    while True:
        time.sleep(1)
        if not books:
            Lock.locked() 
            print('图书馆没有书了')
            continue
        if Lock.locked():
            Lock.release()
        n = random.randint(1, books) + 1
        if books - n < 0:
            n = books
        books -= n
        b_rt += n
        print(f"借出去了{n}本，还剩{books}，外面{b_rt}")


def rt():
    global b_rt
    global books
    while True:
        time.sleep(2)
        if not b_rt:
            Lock.locked()
            continue
        if Lock.locked():
            Lock.release()
        m = random.randint(1, b_rt) - 1
        books += m
        b_rt -= m
        print(f"归还{m}本，还剩{books}，外面{b_rt}")


t1 = threading.Thread(target=rent, args=())
t2 = threading.Thread(target=rt, args=())
ba() # Timer任务会独立启用一个线程
t1.start()
t2.start()
t1.join()
t2.join()

下面面向对象的角度看线程

import threading
import time


# 创建一个线程类
class Eat(threading.Thread):
    def __init__(self, name, s: int):
        # 类继承要注意super函数，这里的target可以不写，默认是run。目的是线程启动调用的是run方法
        super(Eat, self).__init__(target=self.run)
        self.name = name
        self.s = s  # 定义一个时间间隔

    def run(self):  # 构建主函数。线程启动后运行的是此方法
        while True:
            time.sleep(self.s)
            print(f"{self.name}在吃饭")


if __name__ == '__main__':
    aron = Eat("aron", 5)
    aron.start()  # 线程启动后会持续运行
    # 再实例一个线程
    lily = Eat("lily", 2)
    lily.start()
    # 所有线程都运行再一个进程上，他们单独运行互不影响。除非他们调用了进程上的公共属性
    # 比如你可以把时间设置为进程上的一个变量，例如：
    # step = 2
    # aron = Eat("aron", step)
    # lily = Eat("lily", step)

那么你可以试试看能不能用面向对象的方法实现生产者消费者模型吧。

python队列与多线程——生产者消费者模型