Python-48多进程 队列

for循环创建子进程并等待所有进程执行结束

# 饶茹模块
from multiprocessing import Process
import time as aa
# 定义一个函数 sleep模拟执行时间
def css():
    aa.sleep(1)
    print('xxx')

# Windows 下创建多进程必须格式
if __name__ == '__main__':
	# 定义一个列表
    a_list = []
    # 循环创建十个进程并启动,并且将其追加到列表中
    for i in range(10):
        a = Process(target=css,)
        a.start()
        a_list.append(a)
    # 循环列表,等待所有进程执行结束
    for c in range(len(a_list)):
        a_list[c].join()
    # 输出最后内容
    print("主进程结束")

队列 Queue

简单使用

# 队列:在两个进程执行过程中 进行通信
from multiprocessing import Process,Queue

# 队列 先进先出
# 实例化一个对象 3是最多可以放入三个
q = Queue(3)
# 放入数据
q.put(1)
q.put(2)
# qsize 会输出当前队列中已经放了多少 返回当前队列中内容长度
print("qsize:",q.qsize())
q.put(3)
# 检查队列是否已经满了 如果是则返回True 多进程的时候不可靠 因为执行后瞬间另一个进程可能会执行操作 取到的不准确
print("队列是否满了",q.full())
# 此时 队列中已经放满了 如果在加一个 q.put(4) ,执行的时候进程会在此阻塞,所以使用另一种
try:
    q.put_nowait(4) # 不等待 此时放入的时候如果队列满了 直接报异常
except:
    print("队列满了")
# 获取队列中的一个数据
print(q.get())
print(q.get())
print(q.get())
# 队列中最多只能放三个 也最多只能取出三个 如果队列已经空了 再次取值会再次卡主
# print(q.get())
# 异常处理 如果使用nowait 此处会抛异常
try:
    print(q.get_nowait())
except:
    print("队列已经空了")

基于队列的进程之间简单通信

# 队列:在两个进程执行过程中 进行通信
from multiprocessing import Process,Queue
def process1(que):
    # 将东西放进队列中
    que.put("hello")

if __name__ == '__main__':
	# 创建一个队列
    que = Queue(3)
    process2 = Process(target=process1,args=(que,))
    process2.start()
    # 此处从队列中取值 如果取不到会再次等待
    print(que.get())

模拟产品生产消费过程

from multiprocessing import Process,Queue
from time import sleep as shui

# 生产者进程
def Production(que):
	# 利用循环,每隔1秒放进队列中一个,模拟每隔一秒生产一个
    for i in range(20):
        shui(1)
        Product = '产品%s号'%i
        que.put(Product)
        print("产品%s号已生产"%i)
    print("产品生产结束!")
# 消费者进程
def Consumption(que):
	# 利用循环,两秒消费一个产品
    for i in range(20):
        shui(2)
        que.get()
        print("产品%s号已被使用"%i)
    print("产品消费结束!")

if __name__ == '__main__':
	# 创建队列
    que = Queue(10)
    # 启动进程
    Pro = Process(target=Production,args=(que,))
    Con = Process(target=Consumption,args=(que,))
    Pro.start()
    Con.start()

以上情况是产品生产快,并且知道有多少产品,如果不知道情况下,并且生产不如消费快,则会出现异常,如果消费快的话,那么消费的程序直接结束了.

from multiprocessing import Process,Queue
from time import sleep as shui

def Production(que):
    for i in range(10):
        shui(0.5)
        Product = '产品%s号'%i
        que.put(Product)
        print("产品%s号已生产"%i)
    # 双方约定信号 对方如果取到这个信号 则表示生产完成了
    que.put(None)
    print("产品生产结束!")
def Consumption(que):
    i = 0
    while True:
        shui(0.2)
        # 从队列中取出方式不变,取出之后则进行判断,检查是否是结束信号,如果是的话则跳出循环 则进程执行结束
        Consumption1 = que.get()
        if Consumption1 == None:
            break
        print("产品%s号已被使用"%i)
        i += 1
    print("产品消费结束!")

if __name__ == '__main__':
    que = Queue(10)
    Pro = Process(target=Production,args=(que,))
    Con = Process(target=Consumption,args=(que,))
    Pro.start()
    Con.start()

基于JoinableQueue 模块方式

from multiprocessing import Process,Queue,JoinableQueue
from time import sleep as shui

def Production(que):
    for i in range(10):
        shui(0.5)
        str = "产品%s号"%i
        que.put(str)
        print(str+"已经生产")
    # 在生产结束之后 等待消费进程的task_done信号 收到之后再向下执行
    que.join()
    print("生产结束!")

def Consumption(que):
    while True:
        shui(1)
        Consumption_a = que.get()
        print(Consumption_a+'已经消费!')
        # 当消费结束后 会给生产进程发送一个task_done信号
        que.task_done()

if __name__ == '__main__':
    que = JoinableQueue(10)
    process_production = Process(target=Production,args=(que,))
    process_consumption = Process(target=Consumption,args=(que,))
    process_production.start()
    # 将消费进程设置为守护进程
    process_consumption.daemon = True
    process_consumption.start()
    # 等待执行结束
    process_production.join()
    print("生产消费结束")

解析:
首先会建立两个进程,一个生产进程,一个消费进程,将消费进程设置为守护进程,这样在主进程结束后消费进程也会被结束掉,然后开始了生产消费关系,生产者每个一秒放入队列中一个产品,并且记录下一个序号,消费者(可以比生产快或者慢)每隔一定时间去取出一个,同时给生产进程发送了一个task_done信号,里面包含了消费掉产品的序号,但是此时生产进程还在生产中,并没有接收这个信号,等待生产进程全部生产结束后(也就是for循环结束了),程序向下运行,执行que.join()方法,此处生产了十个产品,等待消费者的task_done信号和消费的序号,此时生产进程再次阻塞,消费进程(如果比生产慢的情况)还在消费中,当消费结束了,发送给生产进程task_done信号和消费的序号,生产进程接收到task_done和消费的序号后发现消费掉的和生产的产品数量(10个)完全相符,也就是全部消费结束,程序不再阻塞向下运行,主程序设置了process_production.join()等待生产进程执行结束,所以生产进程结束之后主程序向下运行,输出了’生产消费结束’字样后主进程执行完毕结束,同时作为守护进程的消费进程也被结束掉.程序执行完毕.