多进程
进程：正在进行的一个过程或者说一个任务。而负责执行任务的是cpu。
进程与程序的区别：程序仅仅是一堆代码，而进程指的是程序的运行过程。
并发与并行：
无论是并行还是并发，在用户看来都是'同时'运行的，不管是进程还是线程，都只是一个任务而已，真是干活的是cpu，cpu来做这些任务，而一个cpu同一时刻只能执行一个任务
- 并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发
- 并行：同时运行，只有具备多个cpu才能实现并行
Process类
# Process类
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，可用来开启一个子进程
强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号# 参数
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称# 方法
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间。# 属性
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid开启进程的方法
在windows中Process()必须放到# if name == 'main':下
# 方式一
from multiprocessing import Process
import time
def task(name):
print('%s is running' % name)
time.sleep(3)
print('%s is done' % name)
if __name__ == '__main__':
p = Process(target=task, args=('processing1',))
# Process(target=task, kwargs={'name': 'processing1'})
p.start() # 仅给操作系统发送了一个信号
print('main')# 方式二
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print('%s is running' % self.name)
time.sleep(3)
print('%s is done' % self.name)
if __name__ == '__main__':
p = MyProcess('processing1')
p.start() # 调用了run()方法
print('main')join方法
当主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让主进程检测子进程是否运行完毕，在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用
from multiprocessing import Process
import time
import random
import os
def task():
print('%s is piaoing' % os.getpid())
time.sleep(random.randrange(1, 3))
print('%s is piao end' % os.getpid())
if __name__ == '__main__':
p=Process(target=task)
p.start()
p.join() # 等待p停止,才执行下一行代码
print('主')守护进程
- 守护进程会在主进程代码执行结束后就终止
- 守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
from multiprocessing import Process
import time
import random
def task(name):
print('%s is piaoing' % name)
time.sleep(random.randrange(1, 3))
print('%s is piao end' % name)
if __name__ == '__main__':
p=Process(target=task,args=('q1ang', ))
p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
p.start()
print('主') #只要终端打印出这一行内容，那么守护进程p也就跟着结束掉了互斥锁
进程之间数据不共享，但是共享同一套文件系统,所以访问同一个文件，或同一个打印终端,是没有问题的，而共享带来的是竞争，竞争带来的结果就是错乱。
互斥锁的原理，就是把并发改成穿行，降低了效率，但保证了数据安全不错乱
# 由并发变成了串行,牺牲了运行效率,但避免了竞争
from multiprocessing import Process,Lock
import os,time
def work(lock):
lock.acquire() # 加锁
print('%s is running' %os.getpid())
time.sleep(2)
print('%s is done' %os.getpid())
lock.release() # 释放锁
if __name__ == '__main__':
lock=Lock()
for i in range(3):
p=Process(target=work,args=(lock,))
p.start()加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行地修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信，但问题是：
1、效率低（共享数据基于文件，而文件是硬盘上的数据）
2、需要自己加锁处理
因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
队列和管道都是将数据存放于内存中，而队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，因而队列才是进程间通信的最佳选择。
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。
maxsize是队列中允许最大项数，省略则无大小限制。
但需要明确：
1、队列内存放的是消息而非大数据
2、队列占用的是内存空间，因而maxsize即便是无大小限制也受限于内存大小q.put方法用以插入数据到队列中。
q.get方法可以从队列读取并且删除一个元素。from multiprocessing import Process,Queue
q=Queue(3)
# put ,get ,put_nowait,get_nowait,full,empty
q.put(1)
q.put(2)
q.put(3)
print(q.full()) # 满了
# q.put(4) # 再放就阻塞住了
print(q.get())
print(q.get())
print(q.get())
print(q.empty()) # 空了
# print(q.get()) # 再取就阻塞住了生产者消费者模型
为什么要使用生产者消费者模型
生产者指的是生产数据的任务，消费者指的是处理数据的任务，在并发编程中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
什么是生产者和消费者模式
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
这个阻塞队列就是用来给生产者和消费者解耦的
from multiprocessing import Process,Queue
import time,random,os
def consumer(q, name):
while True:
res = q.get()
time.sleep(random.randint(1, 3))
print('\033[43m%s 吃 %s\033[0m' % (name, res))
def producer(q, name, food):
for i in range(3):
time.sleep(random.randint(1, 3))
res='%s%s' %(food, i)
q.put(res)
print('\033[45m%s 生产了 %s\033[0m' % (name, res))
if __name__ == '__main__':
q = Queue()
# 生产者们:即厨师们
p1 = Process(target=producer,args=(q, 'q1ang', '包子'))
# 消费者们:即吃货们
c1 = Process(target=consumer,args=(q,'xxx'))
# 开始
p1.start()
c1.start()
print('主')JoinableQueue([maxsize])
这就像是一个Queue对象，但队列允许项目的使用者通知生成者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。参数介绍
maxsize是队列中允许最大项数，省略则无大小限制。方法介绍
JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：
q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止基于JoinableQueue实现生产者消费者模型
from multiprocessing import Process, JoinableQueue
import time
import random
def consumer(q, name):
while True:
res = q.get()
time.sleep(random.randint(1,3))
print('\033[43m%s 吃 %s\033[0m' % (name, res))
q.task_done() # 发送信号给q.join()，说明已经从队列中取走一个数据并处理完毕了
def producer(q, name, food):
for i in range(3):
time.sleep(random.randint(1,3))
res = '%s%s' %(food,i)
q.put(res)
print('\033[45m%s 生产了 %s\033[0m' % (name, res))
q.join() # 等到消费者把自己放入队列中的所有的数据都取走之后，生产者才结束
if __name__ == '__main__':
q = JoinableQueue() # 使用JoinableQueue()
# 生产者们:即厨师们
p1 = Process(target=producer, args=(q, 'q1ang', '包子1'))
p2 = Process(target=producer, args=(q, 'q1ang', '包子2'))
p3 = Process(target=producer, args=(q, 'q1ang', '包子3'))
# 消费者们:即吃货们
c1 = Process(target=consumer, args=(q, 'xxx'))
c2 = Process(target=consumer, args=(q, 'zzz'))
c1.daemon = True
c2.daemon = True
# 开始
p1.start()
p2.start()
p3.start()
c1.start()
c2.start()
p1.join()
p2.join()
p3.join()
# 1、主进程等生产者p1、p2、p3结束
# 2、而p1、p2、p3是在消费者把所有数据都取干净之后才会结束
# 3、所以一旦p1、p2、p3结束了，证明消费者也没必要存在了，应该随着主进程一块死掉，因而需要将生产者们设置成守护进程
print('主')总结
1、程序中有两类角色
一类负责生产数据（生产者）
一类负责处理数据（消费者）2、引入生产者消费者模型为了解决的问题是
平衡生产者与消费者之间的速度差
程序解开耦合3、如何实现生产者消费者模型
生产者<--->队列<--->消费者