def put(self, obj, block=True, timeout=None):插入數據到隊列中
Block值默認為True，代表當隊列已滿時，會阻塞。如果block為False，則隊列滿會報異常Queue.Full
timeout表示會阻塞到指定時間，直到有剩余的空間供插入，如果時間超時，則報異常Queue.Full
def get(self, block=True, timeout=None):從隊列中取出數據
Block值默認為True，代表當隊列為空時，會阻塞。如果block為False，則隊列空會報異常Queue.Empty
timeout表示會等待到指定時間，直到取出數據，如果時間超時，則報異常Queue.Empty
def empty(self): 判斷隊列是否為空，如果空返回True
def full(self): 判斷隊列是否已滿，如果滿返回True
def qsize(self): 返回隊列的大小

from multiprocessing import Process, Manager
q = Manager().Queue(2)
q.put(1)
q.put(2,block=False,timeout=2)
def func():
    print(q.get())
p = Process(target=func)
print("size",q.qsize())
print("full",q.full())
p.start()
p.join()
print("empty",q.empty())
print("get", q.get())
print("get", q.get(block=False,timeout=2))

from multiprocessing import Process,Manager,active_children
import random
import queue
import time
 
class Producer(Process):
 
    def __init__(self,queue):
        super().__init__()
        self.queue = queue
 
    def run(self):
        for i in range(6):
            r = random.randint(0, 99)
            time.sleep(1)
            self.queue.put(r)
            print("add data{}".format(r))
 
class Consumer(Process):
 
    def __init__(self,queue):
        super().__init__()
        self.queue = queue
 
    def run(self):
        while True:
          if not self.queue.empty():
                data = self.queue.get()
                print("minus data{}".format(data))
 
 
if __name__ == '__main__':
    q = Manager().Queue() # 創建隊列
    p = Producer(q)
    c = Consumer(q)
    p.start()
    c.start()
    print(active_children())  # 查看現有的進程
    p.join()
    c.join()
    print("結束")
 
 

from multiprocessing import Process,JoinableQueue
import os
import time
import random
def print_log(msg, log_type="prod"):
    if log_type == 'prod':
        print("\033[32;1m%s\033[0m" %msg)
    elif log_type == 'con':
        print("\033[31;1m%s\033[0m" %msg)
def producer(q):
    """
    生產者
    :param q: 
    :return: 
    """
    for i in range(10):
        data = random.randint(1,200)
        time.sleep(2)
        q.put(data)  # 放入隊列
        msg = "add data {}".format(data)
        print_log(msg)
    q.join()  # 生產者調用此方法進行阻塞，直到隊列中所有的項目均被處理。
    # 阻塞將持續到隊列中的每個項目均調用q.task_done（）方法為止
def consumer(q):
    """
    消費者
    :param q: 
    :return: 
    """
    while True:
        if not q.empty():
            time.sleep(5)
            data = q.get()
            msg = "minus data{}".format(data)
            print_log(msg,"con")
            q.task_done()  # q.get()的返回項目已經被處理
if __name__ == '__main__':
    q = JoinableQueue()
    prod = Process(target=producer, args=(q,))
    con = Process(target=consumer, args=(q,))
    con.daemon = True  # 設置為守護進程，但是不用擔心，producer內調用q.join保證了consumer已經處理完隊列中的所有元素
    # 開啟進程
    prod.start()
    con.start()
    prod.join()  # 等待生產和消費完成，主線程結束
    print("結束")