day38（多进程） - 信号量、事件、进程队列（进程之间的通信）

from multiprocessing import Process, Semaphore
import time
import random


def action(pro, sem):
    # 控制只有 4 个进程在操作
    # 与 Lock() 一样上锁
    sem.acquire()
    print(pro, '进入了程序')
    time.sleep(random.randint(3, 5))
    print(pro, '结束了程序')
    sem.release()


if __name__ == '__main__':
    p_list = []
    # 只允许 5个 进程同时操作
    sem_obj = Semaphore(5)
    for i in range(1, 21):
        p_obj = Process(target=action, args=('进程-> {}'.format(i), sem_obj))
        p_obj.start()
        p_list.append(p_obj)
    for p_obj in p_list:
        p_obj.join()

from multiprocessing import Event, Process
import time
import random

"""
主进程的事件对象传递到多个函数进程内，
就可以对这些进程做控制
"""


# event = Event()
# 事件的默认状态是 False
# print(event.is_set())

"""
wait() 的阻塞状态是动态的
进程 A 将 event.set() 之后，进程 B 将立即继续执行
进程 A 将 event.clear()之后，进程 B 遇到 wait() 立即进入阻塞
"""


# event 的状态是 False 的时候，会阻塞，不执行下面的代码
# event 的状态是 True 的时候才会执行 wait() 下面的代码
# event.wait()

# 将 event 态改成 True
# event.set()
# print(event.is_set())

# 将 event 状态改成 False
# event.clear()
# print(event.is_set())

# 模拟红绿灯，设置事件的阻塞状态
def light_action(event):
    while 1:
        # 事件的默认状态是 False
        print('>>>红灯亮了<<<')
        time.sleep(10)
        event.set()
        print('===绿灯亮了===')
        time.sleep(10)
        event.clear()


# 模拟车辆
def car_action(event, pro_car):
    # 模拟绿灯
    while 1:
        if event.is_set():
            print(pro_car, '===过去了===')
            break
        else:
            print(pro_car, '>>>在等待<<<')
            event.wait()
            time.sleep(random.randint(1, 5))


if __name__ == '__main__':
    # 设置一个全局的事件，控制进程之间的阻塞
    event_obj = Event()
    # 一个进程用来模拟红绿灯，设置事件阻塞
    p_light = Process(target=light_action, args=(event_obj,))
    p_light.start()

    for i in range(1, 101):
        # 随机来车辆
        time.sleep(random.randint(1, 3))
        p_car = Process(target=car_action, args=(event_obj, '车辆-> {}'.format(i)))
        p_car.start()

from multiprocessing import Process, JoinableQueue
import time
import random


def producer(p_name, que):
    for num in range(1, 6):
        time.sleep(random.randint(1, 3))
        content = p_name + '创造了数据' + str(num)
        print('>>>', content, '<<<')
        # .put()，将生产的数据放进全局队列
        que.put(content)
    que.put(None)  # 最后放一个 None，告知生产者已经结束生产
    # que.join()  # 生产者调用此方法进行阻塞，直到队列中所有的项目均调用q.task_done()，生产者程序就结束
    # print('生产者结束')


def consumer(p_name, que):
    while 1:
        # .get()，从队列中拿数据
        # 拿一个队列中就少一个
        # 先放进队列的数据，就先被拿出来
        queue_content = que.get()
        if queue_content is None:
            que.task_done()
            break
        print('===', p_name, '拿到了', queue_content, '===')
        # que.task_done()  # get() 并处理完一个数据，告知生产者该任务已经被处理


if __name__ == '__main__':
    # 队列是全局的，在不同进程之间可传递参数
    que_obj = JoinableQueue()
    # 生产者进程
    for i in range(1, 4):
        p_creator = Process(target=producer, args=('生产者-> {} '.format(i), que_obj))
        p_creator.start()

    # 消费者进程
    for i in range(1, 3):
        p_customer = Process(target=consumer, args=('消费者-> {} '.format(i), que_obj))
        p_customer.start()