进程基础及多进程的使用
进程基础及多进程的使用
一 进程理论知识
1 操作系统的作用
1).隐藏丑陋复杂的硬件接口，提供良好的抽象接口；应用程序员有了这些接口后，就不用再考虑操作硬件的细节，专心开发自己的应用程序即可。
2).管理、调度进程，并且将多个进程对硬件的竞争变的有序。
2 多道技术
2.1 产生背景：
针对单核，实现并发。
多道技术中的多道指的是多个程序，多道技术的实现是为了解决多个程序竞争或者说共享同一个资源(比如cpu) 的有序调度问题，解决方式即多路复用，多路复用分为时间上的复用和空间上的复用。
PS：现在的主机一般都是多核，那么每个核都会利用多道技术。有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个cpu中的任意一个，具体由操作系统调度算法决定。
2.2 空间上的复用：如内存中同时有多道程序
将内存分为几部分，每个部分放入一个程序，这样，同一时间内存中就有了多道程序。
2.3 时间上复用：复用一个cpu的时间片
当一个程序在等待I/O时，另一个程序可以使用cpu，如果内存中可以同时存放足够多的作业，则cpu的利用率可以接近100%，即统筹的执行任务。(操作系统采用了多道技术后，可以控制进程的切换，或者说进程之间去争抢cpu的执行权限。这种切换不仅会在一个进程遇到io时进行，一个进程占用cpu时间过长也会切换，或者说被操作系统夺走cpu的执行权限) 。
3 程序
程序就是一堆代码文件。
4 进程
进程是一个抽象的概念，就是一个程序的运行过程。
负责执行令进程的是CPU。
进程是操作系统最核心的概念。
# "注意："
同一个程序执行两次，那也是两个进程。
4.1 进程的创建
windows：CreateProcess
Linux：fork
4.2 进程的终止
1).正常退出
2).被其他进程杀死(win：task /F /PID 进程编号)
4.3 程序运行的三种状态
1).运行态；2).就绪态；3).阻塞态。
4.4 程序优化的核心法则
1).降低IO操作(硬盘IO、网络IO) 2).减少网络IO：内存IO==》本地硬盘IO==》网络IO
4.5 进程的三种状态于调用任务的两种方式
4.5.1 进程的三种状态
#### (1) 非阻塞态之运行态； 即程序正在运行。#### (2) 非阻塞态之就绪态； 即程序在准备运行，如下图所示。#### (3) 阻塞态。 阻塞调用是指调用结果返回之前，当前线程会被挂起(如遇到IO操作) 。函数只有在得到结果之后才会将阻塞的线程激活。 阻塞调用和同步调用实际上是不同的，对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。
4.5.2 调用任务的两种方式
#### (1) 同步调用 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。 按照这个定义，大多数函数都是同步调用。但是一般而言，我们在说同步，异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。#### (2) 异步调用 异步概念和同步相对。当一个异步功能调用发出后，调用者不能立刻得知结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。 如果异步功能用状态来通知，那么调用者就需要每隔一定的时间检查一次，效率就很低。如果使用通知的方式，效率则很高。因为异步功能几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。
4.5.3 小结
#### (1) 同步与异步针对的是函数/任务的调用方式： 同步就是当一个进程发起一个函数(任务) 调用的时候，一直等到函数(任务) 完成，而进程继续处于激活状态。 而异步情况下是当一个进程发起一个函数(任务) 调用的时候，不会等函数返回，而是继续往下执行，当函数返回的时候通过状态、通知、事件等方式通知进程任务的完成。#### (2) 阻塞与非阻塞针对的是进程或线程： 阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程。
5 串行、并发与并行
无论是并发与并行，在用户看来都是“同时”运行的，不管是进程还是线程，都只是一个任务而已，真正干活的是CPU，CPU来做者写任务，而一个CPU同一时刻只能执行一个任务。# 1).串行 一个运行完毕再运行下一个。# 2).并发 是伪并行，及看起来是同时运行。单个cpu与多道技术可以实现并发，(并行也属于并发) 。# 3).并行 同时运行，只有具有多个cpu才可以实现并行。 单核下，可以利用多道技术，多个核，每个核也可以利用多道技术(多道技术是针对单核而言的) 。 有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4，一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，这就是单核下的多道技术，而一旦任务1的I/O结束了，操作系统会重新调用它('''需知进程的调度、分配给哪个cpu运行，由操作系统说了算''')，可能被分配给四个cpu中的任意一个去执行。
6 线程
在传统的操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程。 线程顾名思义，就是一条流水线工作的过程，一条流水线必须属于一个车间，一个车间的工作过程是一个进程车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一个流水线流水线的工作需要电源，电源就相当于cpu所以，"""进程只是用来把资源集中到一起(进程只是一个资源单位，或者说资源集合) ，而线程才是cpu上的执行单位。""" 多线程(即多个控制线程) 的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。
二 python并发之multiprocessing模块
1 什么是multiprocessing模块
multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务(比如函数) 。 multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。 # "注意：" 与线程不同，进程没有任何共享状态，进程修改的数据，改动仅限于该进程内。
2 Process类介绍
2.1 创建进程的类：
Process([group [, target [, name [, args [, kwargs]]]]])# 由该类实例化得到的对象，表示一个子进程中的任务(尚未启动) # 注意：1) 需要使用关键字的方式来指定参数；2) args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号。
2.2 参数介绍：
1) group 参数未使用，值始终为None；2) target 表示调用对象，即子进程要执行的任务；3) args 表示调用对象的位置参数元组，args = (1, 2, 'lxx')4) kwargs 表示调用对象的字典， kwargs = {'name':'lxx', 'age':'18'}5) name 为子进程的名称。
2.3 方法介绍：
1) p.start(): 启动进程，并调用该子进程中的p.run();2) p.run(): 进程启动时运行的方法，正是他去调用target指定的函数，我们自定义类的类中一定要实现该方法；3) p.terminate(): 强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法时需要特别小心这种情况。如果p还保存了一个锁，那么也将不会被释放，进而导致死锁。4) p.is_alive(): 如果p仍然运行，返回True。5) p.join([timeout]): 主线程等待p终止，(强调：是主线程处于等的状态，而p是处于运行的状态) 。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程。
2.4 属性介绍：
1) p.deamon: 默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置。2) p.name: 进程的名称。3) p.pid: 进程的pid。4) p.exitcode: 进程在运行时为None、如果为–N，表示被信号N结束(了解即可)。5) p.authkey: 进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功(了解即可) 。
3 Process类的使用
"注意：在Windows系统中，Process() 必须到 ： if __ name __ == '__ main __' : 下"
3.1 创建并开启子进程的两种方式：
"由于子进程的创建需要调动系统的资源，所以子进程启动时间上有延迟"，示例代码展示了这种延迟：
(1)：方式一：使用函数的方式
# 创建子进程的方式一：import timeimport randomfrom multiprocessing import Processdef task(name): print('%s is running' % name) time.sleep(random.randrange(1, 5)) print('%s is ending' % name)if __name__ == '__main__': # 必须加这一行，不然win下运行会报错 p1 = Process(target=task, args=('子进程1',)) # 元组，必须加逗号！ p2 = Process(target=task, args=('子进程2',)) p3 = Process(target=task, args=('子进程3',)) p4 = Process(target=task, args=('子进程4',)) p1.start() p2.start() p3.start() p4.start() print('______主进程————————————————————>>>>>') """______主进程————————————————————>>>>>子进程1 is running子进程2 is running子进程3 is running子进程4 is running子进程3 is ending子进程2 is ending子进程4 is ending子进程1 is ending"""
(2)：方式二：使用类的方式
# 创建子进程的方式二：import timeimport randomfrom multiprocessing import Processclass task(Process): def __init__(self, name): super().__init__() self.name = name def run(self): print('%s is running' % self.name) time.sleep(random.randrange(1, 5)) print('%s is ending' % self.name)if __name__ == '__main__': p1 = task('子进程1') p2 = task('子进程2') p3 = task('子进程3') p4 = task('子进程4') p1.start() # start会自动调用run p2.start() p3.start() p4.start() print('______主进程————————————————————>>>>>') """______主进程————————————————————>>>>>子进程1 is running子进程4 is running子进程3 is running子进程2 is running子进程1 is ending子进程3 is ending子进程2 is ending子进程4 is ending"""
3.2 进程之间的内存空间是隔离的：
子进程和主进程之间的内存空间是隔离的。
# 进程之间的内存空间是隔离的from multiprocessing import Processn = 100def work(): global n n = 0 print('子进程内：', n)if __name__ == '__main__': p = Process(target=work) p.start() print('主进程内：', n) """主进程内： 100子进程内： 0"""
3.3 Process对象的join方法：
# "作用：" 主进程，等待子进程结束。 # "注意：" join()方法不是让多个程序变成串行，是让主进程等待某个子进程一段时间后再运行，卡住的是主进程，其余的子进程仍然是并发的执行，让主进程等待多久，取决于join()时间最长的一个。
# Process对象的join方法: 让主进程等待import timeimport randomfrom multiprocessing import Processclass task(Process): def __init__(self, name): super().__init__() self.name = name def run(self): print('%s is running' % self.name) time.sleep(random.randrange(1, 5)) print('%s is ending' % self.name)if __name__ == '__main__': p1 = task('子进程1') p2 = task('子进程2') p3 = task('子进程3') p4 = task('子进程4') print(time.time(),'——————> 001') p1.start() # start会自动调用run print(time.time(),'——————> 002') p1.join(1.5) # 自p1启动那一刻起，让主进程等待1.5s再执行 print(time.time(),'——————> 003') p2.start() p3.start() p4.start() print(time.time(),'——————> 004') print('______主进程————————————————————>>>>>') print(time.time(),'——————> 005') """1597927218.6315486 ——————> 0011597927218.652153 ——————> 002子进程1 is running1597927220.1582189 ——————> 0031597927220.179413 ——————> 004______主进程————————————————————>>>>>1597927220.179413 ——————> 005子进程2 is running子进程3 is running子进程4 is running子进程4 is ending子进程1 is ending子进程2 is ending子进程3 is ending"""
#上述启动进程与join进程可以简写为p_l=[p1,p2,p3,p4]for p in p_l: p.start()for p in p_l: p.join()
3.4 Process对象的其他方法：
(1)：terminate, is_alive方法
# Process对象的其他方法: terminate, is_aliveimport timeimport randomfrom multiprocessing import Processclass task(Process): def __init__(self, name): super().__init__() self.name = name def run(self): print('%s is running' % self.name) time.sleep(random.randrange(1, 5)) print('%s is ending' % self.name)if __name__ == '__main__': p1 = task('子进程1') p2 = task('子进程2') p3 = task('子进程3') p4 = task('子进程4') p1.start() # start会自动调用run p1.join(1.5) # 自p1启动那一刻起，让主进程等待1.5s再执行 p1.terminate() # 关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活 print(p1.is_alive()) # True p2.start()
(2)：子进程名字的设置
# Process对象的其他方法: 子进程名字的设置import timeimport randomfrom multiprocessing import Processclass task(Process): def __init__(self, name): # super().__init__() # self.name = name self.name = name super().__init__() # Process的__init__方法会执行self.name=task-1,根据子进程的个数依次编号 # #所以加到这里,会覆盖我们的self.name=name def run(self): print('%s is running' % self.name) time.sleep(random.randrange(1, 5)) print('%s is ending' % self.name)if __name__ == '__main__': p1 = task('子进程1') p2 = task('子进程2') p3 = task('子进程3') p1.start() # start会自动调用run p2.start() p3.start() print('______主进程————————————————————>>>>>') """______主进程————————————————————>>>>>task-2 is runningtask-1 is runningtask-3 is runningtask-1 is endingtask-2 is endingtask-3 is ending"""
浙公网安备 33010602011771号