在一篇文章中了解 Python 进程间通信的几种方式

from multiprocessing import Process, Pipe
import time


def consumer(p, name):
    left, right = p
    left.close()
    while True:
        try:
            baozi = right.recv()
            print('%s 收到包子:%s' % (name, baozi))
        except EOFError:
            right.close()
            break


def producer(seq, p):
    left, right = p
    right.close()
    for i in seq:
        left.send(i)
        time.sleep(1)
    else:
        left.close()


if __name__ == '__main__':
    left, right = Pipe()

    c1 = Process(target=consumer, args=((left, right), 'c1'))
    c1.start()

    seq = (i for i in range(10))
    producer(seq, (left, right))

    right.close()
    left.close()

    c1.join()
    print('进程间通信-管道-主进程')

c1 收到包子:0
c1 收到包子:1
c1 收到包子:2
c1 收到包子:3
c1 收到包子:4
c1 收到包子:5
c1 收到包子:6
c1 收到包子:7
c1 收到包子:8
c1 收到包子:9
进程间通信-管道-主进程

from multiprocessing import Process, Queue, set_start_method
import time,random,os


def consumer(q):
    while True:
        res=q.get()
        if res is None: break #收到结束信号则结束
        time.sleep(random.randint(1,3))
        print('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res))


def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        res='包子%s' %i
        q.put(res)
        print('\033[46m%s 生产了 %s\033[0m' %(os.getpid(),res))
    q.put(None) #发送结束信号


if __name__ == '__main__':
    set_start_method('fork')

    q=Queue()
    #生产者们:即厨师们
    p1=Process(target=producer,args=(q,))

    #消费者们:即吃货们
    c1=Process(target=consumer,args=(q,))

    #开始
    p1.start()
    c1.start()
    print('进程间通信-队列-主进程')

进程间通信-队列-主进程
25720 生产了 包子0
25720 生产了 包子1
25720 生产了 包子2
25721 吃 包子0
25720 生产了 包子3
25721 吃 包子1
25721 吃 包子2
25720 生产了 包子4
25721 吃 包子3
25720 生产了 包子5
25721 吃 包子4
25720 生产了 包子6
25721 吃 包子5
25721 吃 包子6
25720 生产了 包子7
25720 生产了 包子8
25721 吃 包子7
25721 吃 包子8
25720 生产了 包子9
25721 吃 包子9

from multiprocessing import Manager, Process,Lock

def work(d,lock):
      with lock: # 不加锁而操作共享的数据,肯定会出现数据错乱
        print(f"计数器减一，当前为：{d['count']}")
        d['count']-=1


if __name__ == '__main__':
    lock=Lock()
    with Manager() as m:
        dic=m.dict({'count':20})
        p_l=[]
        for i in range(20):
            p=Process(target=work, args=(dic, lock))
            p_l.append(p)
            p.start()

        for p in p_l:
            p.join()
        print(dic)

计数器减一，当前为：20
计数器减一，当前为：19
计数器减一，当前为：18
计数器减一，当前为：17
计数器减一，当前为：16
计数器减一，当前为：15
计数器减一，当前为：14
计数器减一，当前为：13
计数器减一，当前为：12
计数器减一，当前为：11
计数器减一，当前为：10
计数器减一，当前为：9
计数器减一，当前为：8
计数器减一，当前为：7
计数器减一，当前为：6
计数器减一，当前为：5
计数器减一，当前为：4
计数器减一，当前为：3
计数器减一，当前为：2
计数器减一，当前为：1
{'count': 0}

from multiprocessing import Process,Semaphore
import time,random

def go_wc(sem,user):
    sem.acquire()
    print('%s 占到一个茅坑' %user)
    time.sleep(random.randint(0,3)) # 模拟每个人拉屎速度不一样，0代表有的人蹲下就起来了
    sem.release()


if __name__ == '__main__':
    sem=Semaphore(5)
    p_l=[]
    for i in range(13):
        p=Process(target=go_wc,args=(sem,'user%s' %i,))
        p.start()
        p_l.append(p)

    for i in p_l:
        i.join()
    print('============》')

user0 占到一个茅坑
user1 占到一个茅坑
user2 占到一个茅坑
user3 占到一个茅坑
user5 占到一个茅坑
user4 占到一个茅坑
user7 占到一个茅坑
user9 占到一个茅坑
user8 占到一个茅坑
user6 占到一个茅坑
user11 占到一个茅坑
user12 占到一个茅坑
user10 占到一个茅坑
============》

import multiprocessing
import time

from multiprocessing import Process, Queue, set_start_method

event = multiprocessing.Event()

def xiao_fan(event):
    print('小贩：生产...')
    print('小贩：售卖...')
    # time.sleep(1)
    print('小贩：等待就餐')
    event.set()
    event.clear()
    event.wait()
    print('小贩：谢谢光临')
    event.set()
    event.clear()


def gu_ke(event):
    print('顾客：准备买早餐')
    event.set()
    event.clear()
    event.wait()
    print('顾客：买到早餐')
    print('顾客：享受美食')
    # time.sleep(2)
    print('顾客：付款，真好吃...')
    event.set()
    event.clear()


if __name__ == '__main__':
    set_start_method('fork', True)

    # 创建进程
    xf = multiprocessing.Process(target=xiao_fan, args=(event,))
    gk = multiprocessing.Process(target=gu_ke, args=(event, ))
    # 启动进程

    gk.start()
    xf.start()

    # time.sleep(2)

顾客：准备买早餐
小贩：生产...
小贩：售卖...
小贩：等待就餐
顾客：买到早餐
顾客：享受美食
顾客：付款，真好吃...
小贩：谢谢光临