Produtor Python e processamento síncrono de condição de consumidor e processamento de fila

Condição de uso para realizar o processamento de sincronização de espera pela operação de despertar e produção e consumo;

import threading,time,sched

class Message:
    def __init__(self,condition):
        self._title = None;
        self._content = None;
        self._flag = True;
        self._condition = condition;

    def set_info(self,title,content):
        self._condition.acquire();
        if self._flag == False:
            self._condition.wait();
        self._title = title;
        time.sleep(1);
        self._content = content;
        print("{}-title = {},content = {}".format(threading.current_thread().name,self._title,self._content));
        self._flag = False;
        self._condition.notify();
        self._condition.release();

    def __str__(self):
        self._condition.acquire();
        if self._flag == True:
            self._condition.wait();
        try:
            time.sleep(0.8);
            return "{}-title = {},content = {}".format(threading.current_thread().name,self._title,self._content);
        finally:
            self._flag = True;
            self._condition.notify();
            self._condition.release();

# 生产者处理函数
def producer_handle(message):
    for num in range(50):
        if num % 2 == 0:
            message.set_info("奥特曼","奥特曼打怪兽");
        else:
            message.set_info("黑猫警长","黑猫警长抓老鼠");

# 消费者处理函数
def consumer_handle(message):
    for num in range(50):
        print(message);

def main():
    # 实例化条件锁
    condition = threading.Condition();
    # 公共保存的数据对象
    message = Message(condition);
    prodecer_thread = threading.Thread(target=producer_handle,name = "生产者线程",args=(message,));
    consumer_thread = threading.Thread(target=consumer_handle,name = "消费者线程",args=(message,));
    prodecer_thread.start();
    consumer_thread.start();

if __name__ == '__main__':
    main();

Haverá um problema ao usar isso, um é produzido e outro é consumido, então se o consumo não acabar, a produção não vai continuar, então haverá um desperdício de recursos, se você usou mq, isso é bem entendido , use filas para resolver esta questão;
Python fornece um módulo de fila para implementar
1.queue.Queue fila síncrona primeiro a entrar, primeiro a sair
2.queue.LifoQueue fila síncrona por último a entrar, primeiro a sair
3.queue.PriorityQueue fila de prioridade

Não haverá problemas de desempenho neste momento e não há necessidade de usar um mecanismo de sincronização;

import threading,time,queue

class Message:
    def __init__(self):
        self._title = None;
        self._content = None;

    def set_info(self,title,content):
        self._title = title;
        self._content = content;
        time.sleep(0.1);
        print("{}-title = {},content = {}".format(threading.current_thread().name,self._title,self._content));

    def __str__(self):
        time.sleep(0.8);
        return "{}-title = {},content = {}".format(threading.current_thread().name,self._title,self._content);

# 生产者处理函数
def producer_handle(work_queue):
    for num in range(50):
        message = Message();
        if num % 2 == 0:
            message.set_info("奥特曼","奥特曼打怪兽:{}".format(num));
        else:
            message.set_info("黑猫警长","黑猫警长抓老鼠:{}".format(num));
        work_queue.put(message);
# 消费者处理函数
def consumer_handle(work_queue):
    for num in range(50):
        print(work_queue.get());

def main():

    # 创建5个队列
    work_queue = queue.Queue(5);
    prodecer_thread = threading.Thread(target=producer_handle,name = "生产者线程",args=(work_queue,));
    consumer_thread = threading.Thread(target=consumer_handle,name = "消费者线程",args=(work_queue,));
    prodecer_thread.start();
    consumer_thread.start();

if __name__ == '__main__':
    main();