进程
进程：正在进行的一个过程或者说一个任务
1.multiprocessing模块介绍
python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了multiprocessing。 multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。
multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，>提供了Process、Queue、Pipe、Lock等组件。
需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
1.1 开启子进程的两种方式
方式一 from multiprocessing import Process import time def task(name): print('%s is running '%name) time.sleep(2) print("%s is done"%name) if __name__ == '__main__': p = Process(target=task,args=('子进程',)) p.start() print("主进程") # 方式二 from multiprocessing import Process import time class MyProcess(Process): def __init__(self,name): super().__init__() self.name = name # 必须是 run 重写父亲的方法 def run(self): print('%s is running '%self.name) time.sleep(2) print("%s is done"%self.name) if __name__ == '__main__': p = MyProcess('子进程') p.start() print('我是主进程') ''' 我是主进程 子进程 is running 子进程 is done
1.2 Process类的介绍
创建进程的类：
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，可用来开启一个子进程
强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
参数介绍：
group参数未使用，值始终为None
target表示调用对象，即子进程要执行的任务
args表示调用对象的位置参数元组，args=(1,2,'yk',)
kwargs表示调用对象的字典,kwargs={'name':'yk','age':18}
name为子进程的名称
方法介绍：
p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回Truep.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间。
属性介绍：p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid
1.3 join方法
如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让主进程检测子进程是否运行完毕，
在子进程执行完毕后才继续执行，否则一直在原地阻塞，这就是join方法的作用
import os from multiprocessing import Process import time def task(name): print('%s is running ' %name) time.sleep(2) if __name__ == '__main__': p1 = Process(target=task, args=('进程1',)) p2 = Process(target=task, args=('进程2',)) p3 = Process(target=task, args=('进程3',)) p1.start() p2.start() p3.start() print(p1.is_alive()) p1.join() p2.join() p3.join() print("主进程", os.getpid()) print(p1.is_alive()) ''' 进程1 is running 进程2 is running 进程3 is running 主进程 18540 False '''
1.4 守护进程
关于守护进程需要强调两点：
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children如果我们有两个任务需要并发执行，那么开一个主进程和一个子进程分别去执行就ok了，如果子进程的任务在主进程任务结束后就没有存在的必要了，那么该子进程应该在开启前就被设置成守护进程。主进程代码运行结束，守护进程随即终止
from multiprocessing import Process import time def task(name): print("%s is running"%name) time.sleep(2) if __name__ == '__main__': p = Process(target=task,args=('子进程1',)) '''守护进程 必须放在start的前面！''' p.daemon = True p.start() print("主进程") #只要终端打印出这一行内容，那么守护进程p也就跟着结束掉 ''' >>主进程 # 注意主进程一旦执行完毕，不管守护进程是否完成，程序终止 '''
from multiprocessing import Process import time def foo(): print(123) time.sleep(1) print("end123") def bar(): print(456) time.sleep(2) print("end456") if __name__ == '__main__': p1 = Process(target=foo) p2 = Process(target=bar) p1.daemon = True # 当主进程结束，p1程序立马结束 p1.start() p2.start() print("main-------") ''' main------- 456 end456 '''
1.5 互斥锁
虽然进程之间是独立的，但是同时操作同一个文件系统，就会发生错乱。我们通过锁的机制，来避免这样的竞争。
from multiprocessing import Process,Lock import time def task(name,mutex): # 上锁 mutex.acquire() print("%s 1"%name) time.sleep(1) print("%s 2"%name) time.sleep(1) print("%s 3"%name) # 释放锁 mutex.release() if __name__ == '__main__': # 申请一把锁 mutex = Lock() for i in range(3): p = Process(target=task,args=('进程%s'%i, mutex)) p.start() ''' 进程0 1 进程0 2 进程0 3 进程1 1 进程1 2 进程1 3 虽然变成了串行，但总算避免了竞争。 '''
模拟抢票
import json from multiprocessing import Process, Lock # 查询票 def search(name): # time.sleep(0.5) dic = json.load(open('db.txt', 'r', encoding='utf-8')) print('<%s> 查看到剩余票数 [%s]' % (name, dic['count'])) # 购票 def get(name): dic = json.load(open('db.txt', 'r', encoding='utf-8')) if dic['count'] > 0: dic['count'] -= 1 # time.sleep(1) json.dump(dic, open('db.txt', 'w', encoding='utf-8')) print('<%s> 购票成功！' % name) def task(name, mutex): search(name) # 上锁 mutex.acquire() get(name) # 释放锁 mutex.release() if __name__ == '__main__': mutex = Lock() for i in range(3): p = Process(target=task, args=('路人%s' % i, mutex)) p.start() ''' <路人0> 查看到剩余票数 [90] <路人0> 购票成功！ <路人1> 查看到剩余票数 [89] <路人1> 购票成功！ <路人2> 查看到剩余票数 [88] <路人2> 购票成功！ '''
总结：
加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行地修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。虽然可以用文件共享数据实现进程间通信，但问题是：
1、效率低（共享数据基于文件，而文件是硬盘上的数据）
2、需要自己加锁处理
因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。
这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
队列和管道都是将数据存放于内存中，而队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，因而队列才是进程间通信的最佳选择。
我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。
1.6 队列
进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的
生产者消费模型
from multiprocessing import Process, Queue import time def producer(q): for i in range(3): res = '包子%s' % i time.sleep(2) print('生产了%s' % res) # 放进队列中 q.put(res) def consumer(q): while True: # 从队列中取走 res = q.get() if res is None: break print('消费者吃了%s' % res) if __name__ == '__main__': q = Queue() # 生产者 p = Process(target=producer, args=(q,)) # 消费者 c = Process(target=consumer, args=(q,)) p.start() c.start() p.join() # 等生产者执行完 q.put(None) # 向队列发送一个空信号，关闭消费者 print("主进程") ''' 生产了包子0 消费者吃了包子0 生产了包子1 消费者吃了包子1 生产了包子2 消费者吃了包子2 主进程 '''
基于JoinableQueue实现生产者消费者模型
from multiprocessing import Process, JoinableQueue import time, random ''' JoinableQueue的实例p除了与Queue对象相同的方法之外还具有： q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。 如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常 q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。 阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止 ''' def consumer(q, name): while True: res = q.get() time.sleep(random.randint(1, 3)) print(' 33[43m%s 吃 %s 33[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(' 33[45m%s 生产了 %s 33[0m' % (name, res)) q.join() # 等到消费者把自己放入队列中的所有的数据都取走之后，生产者才结束 if __name__ == '__main__': q = JoinableQueue() # 使用JoinableQueue() # 生产者们:即厨师们 p1 = Process(target=producer, args=(q, 'dx1', '包子')) p2 = Process(target=producer, args=(q, 'dx2', '骨头')) p3 = Process(target=producer, args=(q, 'dx3', '泔水')) # 消费者们:即吃货们 c1 = Process(target=consumer, args=(q, 'gz1')) c2 = Process(target=consumer, args=(q, 'gz2')) 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('主')