多进程
multiprocessing模块
python中的多线程无法利用多核优势，如果想要充分地使用多核CPU的资源（os.cpu_count()查看），在python中大部分情况需要使用多进程。Python提供了multiprocessing。
multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。
需要再次强调的一点是：与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
Process类的介绍
创建进程的类：
Process(group , target , name, args , kwargs)，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动） 强调： 1. 需要使用关键字的方式来指定参数 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号 参数介绍：
1 group参数未使用，值始终为None 2 3 target表示调用对象，即子进程要执行的任务 4 5 args表示调用对象的位置参数元组，args=(1,2,'egon',) 6 7 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18} 8 9 name为子进程的名称方法介绍：
1 p.start()：启动进程，并调用该子进程中的p.run() 2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法 3 4 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁 5 p.is_alive():如果p仍然运行，返回True 6 7 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程 属性介绍：
1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置 2 3 p.name:进程的名称 4 5 p.pid：进程的pid 6 7 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可) 8 9 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）创建开启子进程的两种方式
注意：在windows中Process()必须放到# if name == 'main':下
方式一：
from multiprocessing import Process import time def task(name): print(f'{name} is running') time.sleep(3) print(f'{name} is done') if __name__ == '__main__': p = Process(target=task,args=('铁憨憨'，)) # p = Process(target=task,kwargs={'name':'铁憨憨'}) 也可以 p.start() print('--主进程--')方式二：
from multiprocessing import Process import time class MyProcess(Process): def __init__(self,name): super().__init__() self.name = name def run(self): print(f'{self.name} is runing') time.sleep(3) print(f'{self.name} is done') if __name__ == '__main__': p = MyProcess('铁憨憨') p.start() print('--主进程--')获取进程及父进程的pid
进程在内存中开启多个，每个进程都有一个唯一标识，用于操作系统区分这些进程
在终端查看进程的pid
在cmd终端输入tasklist
在终端查看执行的进程pid
在终端输入tasklist| findstr 正在运行的程序名
通过代码查看pid
os.getpid()查看子进程
os.getppid()查看父进程
验证进程之间的数据隔离
from muiltprocess import Process import time m = 1000 def task(): global x x = 2 print(x) # 2 if __name__ == "__main__": p = Process(target=task) p.start() time.sleep(1) print(x) #1000 子进程中的内容是从主进程copy过去的，主进程与子进程是两个独立的空间，子进程对变量的修改并不会影响主进程中的变量值。
当变量值是-5—256时遵循小数据池原则，主进程与子进程未修改变量值之前的同名变量是指向相同的地址的。
join方法
'If the optional argument timeout is None (the default), the method blocks until the process whose join() method is called terminates. If timeout is a positive number, it blocks at most timeout seconds. ' # 如果可选参数timeout为none（默认值），该方法将一直阻塞，直到调用join（）方法的进程终止。如果超时为正数，则最多会阻塞超时秒数。join方法其实就是一个阻塞，只不过这个阻塞的结束条件是调用join的子进程结束。
from multiprocessing import Process import time def task(name,sec): time.sleep(sec) print(f'{name}is running') if __name__ == '__main__': p1 = Process(target=task,args=('铁憨憨',1)) p2 = Process(target=task,args=('碎小梦',2)) p3 = Process(target=task,args=('皮皮寒',3)) start_time = time.time() p1.start() p2.start() p3.start() p1.join() # 当p1结束时执行主进程，执行p1耗时1秒，此时p2，p3执行了1秒 p2.join() # 当p2结束时执行主进程，执行p2继续消耗1秒，p3已经执行了2秒 p3.join() # 当p3结束时执行主进程，执行p3继续消耗1秒 print(f'主进程:{time.time()-start_time}之后,执行') # 主程序会在3秒后执行 # 铁憨憨is running # 碎小梦is running # 皮皮寒is running # 主进程:3.315531015396118之后,执行from multiprocessing import Process import time def task(name,sec): time.sleep(sec) print(f'{name}is running') if __name__ == '__main__': p1 = Process(target=task,args=('铁憨憨',1)) p2 = Process(target=task,args=('碎小梦',2)) p3 = Process(target=task,args=('皮皮寒',3)) start_time = time.time() p1.start() p1.join() # p1结束时执行主程序 p2.start() # 等p1执行完后才能执行 p2.join() # p2结束后执行主程序 p3.start() # 等p2执行完后才能执行 p3.join() # p3结束后执行主程序 print(f'主进程:{time.time()-start_time}之后,执行') # 等p3结束后才能执行 # 铁憨憨is running # 碎小梦is running # 皮皮寒is running # 主进程:6.843438625335693之后,执行进程对象的其他属性
from multiprocessing import Process import time def task(name): print(f'{name} is running') time.sleep(3) print(f'{name} is done') if __name__ == '__main__': p = Process(target=task,args=('皮皮寒',) ,name='任务1') # name给进程对象设置name属性 p.start() # print(p.pid) # 获取进程pid号 # print(p.name) # time.sleep(1) p.terminate() # 终止(结束)子进程 # terminate 与 start一样的工作原理: 都是通知操作系统终止或者开启一个子进程,内存中终止或者开启(耗费时间) # time.sleep(1) # print(p.is_alive()) # 判断子进程是否存活 # 只是查看内存中p子进程是否运行. print('===主进程')僵尸进程与孤儿进程
from multiprocessing import Process import time import os def task(name): print(f'{name} is running') print(f'子进程开始了:{os.getpid()}') time.sleep(50) if __name__ == '__main__': p = Process(target=task,args=('皮皮寒',)) p.start() print(f'主进程开始了:{os.getpid()}')
可以看出当主程序运行完时并没有立即结束，而是等子进程运行完之后才结束。所以此时的主进程称之为：僵尸进程。
僵尸进程：内存中只包含主进程的pid，以及子进程的开启时间，结束时间。至于主进程的代码以及文件，数据库数据等等全部消失。完成为子进程收尸的任务。可利用waitpid()方法收尸。僵尸进程有害，父进程(僵尸进程)无限的开启子进程，递归的开启，子进程越来越多，僵尸进程还没有结束，导致进程会越来越多，占用内存。
孤儿进程: 此时如果主进程由于各种原因，提前消失了，它下面的所有的子进程都成为孤儿进程了。孤儿进程无害，如果僵尸进程挂了，init会对孤儿进程进行回收。
守护进程
子进程对父进程可以进行守护。
当父进程执行完时，不管子进程执行情况如何，都直接结束。
from multiprocessing import Process import time import os def task(name): print(f'{name} is running') print(f'子进程开始了:{os.getpid()}') time.sleep(50) if __name__ == '__main__': p = Process(target=task,args=('怼哥',)) p.daemon = True # 将p子进程设置成守护进程,守护主进程,只要主进程结束,子进程无论执行与否,都马上结束. p.start() time.sleep(2) print(f'主进程开始了:{os.getpid()}')守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
