生产者和消费者模型

1. 进程间通信（IPC inter-process communication）

2. 如何实现进程间通信

   1. 将消息放入队列中，由另一个进程从另一个队列中取出
   2. 这种通信方式是非阻塞的，发送进程不需要等待接收进程的相应就可执行
   3. multiprocessing有两种形式通信：队列、管道

3. 管道

   1. stdin
   2. stdout
   3. stderr

4. 队列

   1. 管道+锁就是队列
   2. 队列的特性是FIFO

5. 进程间通信的目的

   1. 进程间传输数据

6. python中如何实现队列

   1. queue模块：创建共享队列
   2. import queue#导入模块
   3. queue = queue.Queue()#创建对象
   4. queue.put()#放数据，数据超出容量，阻塞
   5. q.get() #取数据，没有数据就一直阻塞
   6. q.get_nowait()#取数据？没有数据就报错
   7. q.put_nowait()#放数据？数据超出容量，阻塞
   8. q.empty()#判读队列是否为空
   9. q.full()#判断队列是否满
   10. q.qsize()#获取当前队列大小

子进程与主进程通信
from multiprocessing import Process, Queue

def son_process(queue):
queue = queue.get()
print(queue)

def main_process():
queue = Queue()
task_list = []
for i in range(5):
queue.put(i)
task = Process(target=son_process, args=(queue,))
task.start()
task_list.append(task)
for task in task_list:
task.join()

if name == 'main':
main_process()

子进程与主进程通信

子进程之间通信

from multiprocessing import Process, Queue, Lock

def producer(name, queue):
for i in range(5):
queue.put(f'{name} putting')
print(f'{name} qsize:{queue.qsize()}')

def customer(name, queue, lock):
lock.acquire()
for i in range(5):
print(f'{name} getting:', queue.get())
lock.release()

def main():
queue = Queue(5)
lock = Lock()
task_producer_list = []
task_customer_list = []

for i in range(5):
    task_producer = Process(target=producer, args=(f'producer_{i}', queue,))
    task_producer.daemon = True
    task_producer.start()
    task_producer_list.append(task_producer)
for i in range(2):
    task_customer = Process(target=customer, args=(f'customer_{i}', queue, lock))
    # task_customer.daemon = True
    task_customer.start()
    task_customer_list.append(task_customer)
# for task in task_producer_list:
#     task.join()
for task in task_customer_list:
    task.join()

if name == 'main':
main()