1、概念
关于进程或者线程的一些基本的概念这里不再详述，给出一些参考链接。
- 进程和程序
- 进程（线程）状态
- 并发和并行
- 同步和异步
- 阻塞和非阻塞
参考地址：
2、进程的创建
进程的创建因操作系统不同，方式也不一样。因为目前大部分时间本人都是用的windows系统，这里就以windows系统为例讲解，关于linux系统的创建方式可自行查阅像刚刚文档。
-
multiprocess模块
multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自m ultiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块
2.1、Process类简介
-
Process定义
Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动） 强调： 1. 需要使用关键字的方式来指定参数 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号 参数介绍： 1 group参数未使用，值始终为None 2 target表示调用对象，即子进程要执行的任务 3 args表示调用对象的位置参数元组，args=(1,2,'egon',) 4 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18} 5 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.join只能join住start开启的进程，而不能join住run开启的进程 -
属性
p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置 p.name:进程的名称 p.pid：进程的pid p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可) p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）
2.2、创建进程
-
方式1：调用Process类
import os from multiprocessing import Process def func_one(): print("子进程1") print("子进程1:%s 父进程1:%s" % (os.getpid(), os.getppid())) def func_two(): print("子进程2") print("子进程2:%s 父进程2:%s" % (os.getpid(), os.getppid())) if __name__ == '__main__': p_one = Process(target=func_one) P_two = Process(target=func_two) p_one.start() P_two.start() print("主进程:%s 主进程-父进程:%s" % (os.getpid(), os.getppid())) -
方式2：继承Process类-自定义进程
import os from multiprocessing import Process class MyProcess(Process): def __init__(self, name): super().__init__() self.name = name def run(self): print("进程为%s，父进程为%s" % (os.getpid(), os.getppid())) print("我的名字是%s" % self.name) if __name__ == '__main__': p_one = MyProcess('张三') p_two = MyProcess('李四') p_one.start() # 自动调用run() p_two.start() p_one.join() p_two.join() print("主进程结束")
2.3、守护进程
守护进程就是会随着主进程的结束而结束的进程，具有以下两个特点：
- 守护进程会在主进程代码执行结束后就终止。
- 守护进程内无法再开启子进程，否则抛出异常。
from multiprocessing import Process
from time import sleep
def task1(s, name):
while True:
sleep(s)
print('这是任务', name, '.....')
def task2(s, name):
while True:
sleep(s)
print('这是任务', name, '.....')
if __name__ == '__main__':
p1 = Process(target=task1, name='task1', args=(1, '11'))
p2 = Process(target=task2, name='task2', args=(2, '22'))
p2.daemon = True
p1.start()
p2.start()
print('主线程结束....')
3、进程池
在程序实际处理问题过程中，忙时会有成千上万的任务需要被执行，闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候，我们就需要去创建成千上万个进程么？首先，创建进程需要消耗时间，销毁进程也需要消耗时间。第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，这样反而会影响程序的效率。因此我们不能无限制的根据任务开启或者结束进程。那么我们要怎么做呢？
在这里，要给大家介绍一个进程池的概念，定义一个池子，在里面放上固定数量的进程，有需求来了，就拿一个池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务。如果有很多任务需要执行，池中的进程数量不够，任务就要等待之前的进程执行任务完毕归来，拿到空闲进程才能继续执行。也就是说，池中进程的数量是固定的，那么同一时间最多有固定数量的进程在运行。这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果。
- 创建进程池语法
Pool([numprocess [,initializer [, initargs]]])
- 参数
numprocess：要创建的进程数，默认为cpu_count()的值。
initializer：是每个工作进程启动时要执行的可调用对象，默认为None。
initargs：是要传给initializer的参数组。
-
Python进程池Pool常用方法
p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。 '''需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()''' p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。 '''此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。''' p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成 P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用 -
方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法 obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。 obj.ready():如果调用完成，返回True obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常 obj.wait([timeout]):等待结果变为可用。 obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数 -
示例1：异步且待回调处理函数的线程池
import os import time from multiprocessing import Pool from random import random def task(name): print('任务开始...') start = time.time() time.sleep(random() * 2) end = time.time() # print('任务：{}结束，用时：{}，进程号：{}'.format(name, (end - start), os.getpid())) return '任务：{}结束，用时：{}，进程号：{}'.format(name, (end - start), os.getpid()) container = [] def callback_func(n): container.append(n) if __name__ == '__main__': pool = Pool(5) task_list = ['打游戏', '做饭', '看电视', '听音乐', '吃饭', '学python', '学Java'] for t in task_list: pool.apply_async(task, args=(t,), callback=callback_func) pool.close() pool.join() for c in container: print(c) print('over...') -
示例：同步线程池
import os import time from multiprocessing import Pool from random import random def task(name): print('任务开始...') start = time.time() time.sleep(random() * 2) end = time.time() print('任务：{}结束，用时：{}，进程号：{}'.format(name, (end - start), os.getpid())) if __name__ == '__main__': pool = Pool(5) task_list = ['打游戏', '做饭', '看电视', '听音乐', '吃饭', '学python', '学Java'] for t in task_list: pool.apply(task, args=(t,)) pool.close() pool.join() print('over...')
利用Python进行系统管理的时候，特别是同时操作多个文件目录，或者远程控制多台主机，并行操作可以节约大量的时间。当被操作对象数目不大时，可以直接利用multiprocessing中的Process动态成生多个进程，几个还好，但如果是上百个，上千个目标，手动的去限制进程数量却又太过繁琐，这时候进程池Pool发挥作用的时候就到了。
Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行它。
4、进程间通信
要实现进程间的通信，可以使用队列（容器）和管道。
关于队列和管道定义、常用方法，可以参考：Python基础之进程（Process） -->队列和管道。
-
队列通信示例
import time from multiprocessing import Queue, Process def download(q): print('开始下载...') files = ['book.txt', 'table.jpg', 'girl.png'] for file in files: print('正在下载:', file) q.put(file) time.sleep(1) def store_file(q): while not q.empty(): file = q.get() print('{}保存成功'.format(file)) if __name__ == '__main__': q = Queue(5) d = Process(target=download, args=(q,)) s = Process(target=store_file, args=(q,)) d.start() d.join() s.start() s.join(timeout=5)
上面介绍了关于进程的一些知识，其中关于多进程的数据共享可能出现的问题及解决方案在后续章节统一讲解。
参考文章：
参考视频：https://www.bilibili.com/video/BV1R7411F7JV p268~273
源代码仓库地址：https://gitee.com/gaogzhen/python-study
QQ群：433529853
1385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
