一、操作系统必备的理论知识
顾名思义,进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。
进程的概念起源于操作系统,是操作系统最核心的概念,也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的
PS:即使可以利用的cpu只有一个(早期的计算机确实如此),也能保证支持(伪)并发的能力。将一个单独的cpu变成多个虚拟的cpu(多道技术:时间多路复用和空间多路复用+硬件上支持隔离),没有进程的抽象,现代计算机将不复存在。
1 #一 操作系统的作用: 2 1:隐藏丑陋复杂的硬件接口,提供良好的抽象接口 3 2:管理、调度进程,并且将多个进程对硬件的竞争变得有序 4 5 #二 多道技术: 6 1.产生背景:针对单核,实现并发 7 ps: 8 现在的主机一般是多核,那么每个核都会利用多道技术 9 有4个cpu,运行于cpu1的某个程序遇到io阻塞,会等到io结束再重新调度,会被调度到4个 10 cpu中的任意一个,具体由操作系统调度算法决定。 11 12 2.空间上的复用:如内存中同时有多道程序 13 3.时间上的复用:复用一个cpu的时间片 14 强调:遇到io切,占用cpu时间过长也切,核心在于切之前将进程的状态保存下来,这样 15 才能保证下次切换回来时,能基于上次切走的位置继续运行
2.进程的定义
进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。
1 第一,进程是一个实体。每一个进程都有它自己的地址空间,一般情况下,包括文本区域(text region)、数据区域(data region)和堆栈(stack region)。文本区域存储处理器执行的代码;数据区域存储变量和进程执行期间使用的动态分配的内存;堆栈区域存储着活动过程调用的指令和本地变量。 2 第二,进程是一个“执行中的程序”。程序是一个没有生命的实体,只有处理器赋予程序生命时(操作系统执行之),它才能成为一个活动的实体,我们称其为进程。[3] 3 进程是操作系统中最基本、重要的概念。是多道程序系统出现后,为了刻画系统内部出现的动态情况,描述系统内部各道程序的活动规律引进的一个概念,所有多道程序设计操作系统都建立在进程的基础上。
1 从理论角度看,是对正在运行的程序过程的抽象; 2 从实现角度看,是一种数据结构,目的在于清晰地刻画动态系统的内在规律,有效管理和调度进入计算机系统主存储器运行的程序。
1 动态性:进程的实质是程序在多道程序系统中的一次执行过程,进程是动态产生,动态消亡的。 2 并发性:任何进程都可以同其他进程一起并发执行 3 独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位; 4 异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进 5 结构特征:进程由程序、数据和进程控制块三部分组成。 6 多个不同的进程可以包含相同的程序:一个程序在不同的数据集里就构成不同的进程,能得到不同的结果;但是执行过程中,程序不能发生改变。
1 程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。 2 而进程是程序在处理机上的一次执行过程,它是一个动态的概念。 3 程序可以作为一种软件资料长期存在,而进程是有一定生命期的。 4 程序是永久的,进程是暂时的。
注意:同一个程序执行两次,就会在操作系统中出现两个进程,所以我们可以同时运行一个软件,分别做不同的事情也不会混乱。
3.进程调度
1 先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。由此可知,本算法适合于CPU繁忙型作业,而不利于I/O繁忙型的作业(进程)。
1 短作业(进程)优先调度算法(SJ/PF)是指对短作业或短进程优先调度的算法,该算法既可用于作业调度,也可用于进程调度。但其对长作业不利;不能保证紧迫性作业(进程)被及时处理;作业的长短只是被估算出来的。
1 时间片轮转(Round Robin,RR)法的基本思路是让每个进程在就绪队列中的等待时间与享受服务的时间成比例。在时间片轮转法中,需要将CPU的处理时间分成固定大小的时间片,例如,几十毫秒至几百毫秒。如果一个进程在被调度选中之后用完了系统规定的时间片,但又未完成要求的任务,则它自行释放自己所占有的CPU而排到就绪队列的末尾,等待下一次调度。同时,进程调度程序又去调度当前就绪队列中的第一个进程。 2 显然,轮转法只能用来调度分配一些可以抢占的资源。这些可以抢占的资源可以随时被剥夺,而且可以将它们再分配给别的进程。CPU是可抢占资源的一种。但打印机等资源是不可抢占的。由于作业调度是对除了CPU之外的所有系统硬件资源的分配,其中包含有不可抢占资源,所以作业调度不使用轮转法。 3 在轮转法中,时间片长度的选取非常重要。首先,时间片长度的选择会直接影响到系统的开销和响应时间。如果时间片长度过短,则调度程序抢占处理机的次数增多。这将使进程上下文切换次数也大大增加,从而加重系统开销。反过来,如果时间片长度选择过长,例如,一个时间片能保证就绪队列中所需执行时间最长的进程能执行完毕,则轮转法变成了先来先服务法。时间片长度的选择是根据系统对响应时间的要求和就绪队列中所允许最大的进程数来确定的。 4 在轮转法中,加入到就绪队列的进程有3种情况: 5 一种是分给它的时间片用完,但进程还未完成,回到就绪队列的末尾等待下次调度去继续执行。 6 另一种情况是分给该进程的时间片并未用完,只是因为请求I/O或由于进程的互斥与同步关系而被阻塞。当阻塞解除之后再回到就绪队列。 7 第三种情况就是新创建进程进入就绪队列。 8 如果对这些进程区别对待,给予不同的优先级和时间片从直观上看,可以进一步改善系统服务质量和效率。例如,我们可把就绪队列按照进程到达就绪队列的类型和进程被阻塞时的阻塞原因分成不同的就绪队列,每个队列按FCFS原则排列,各队列之间的进程享有不同的优先级,但同一队列内优先级相同。这样,当一个进程在执行完它的时间片之后,或从睡眠中被唤醒以及被创建之后,将进入不同的就绪队列。
1 前面介绍的各种用作进程调度的算法都有一定的局限性。如短进程优先的调度算法,仅照顾了短进程而忽略了长进程,而且如果并未指明进程的长度,则短进程优先和基于进程长度的抢占式调度算法都将无法使用。 2 而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间,而且还可以满足各种类型进程的需要,因而它是目前被公认的一种较好的进程调度算法。在采用多级反馈队列调度算法的系统中,调度算法的实施过程如下所述。 3 (1) 应设置多个就绪队列,并为各个队列赋予不同的优先级。第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同,在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小。例如,第二个队列的时间片要比第一个队列的时间片长一倍,……,第i+1个队列的时间片要比第i个队列的时间片长一倍。 4 (2) 当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度。当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n 队列便采取按时间片轮转的方式运行。 5 6 (3) 仅当第一队列空闲时,调度程序才调度第二队列中的进程运行;仅当第1~(i-1)队列均空时,才会调度第i队列中的进程运行。如果处理机正在第i队列中为某进程服务时,又有新进程进入优先权较高的队列(第1~(i-1)中的任何一个队列),则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第i队列的末尾,把处理机分配给新到的高优先权进程。
4.进程的并行与并发
并行 : 并行是指两者同时执行,比如赛跑,两个人都在不停的往前跑;(资源够用,比如三个线程,四核的CPU )
并发 : 并发是指资源有限的情况下,两者交替轮流使用资源,比如一段路(单核CPU资源)同时只能过一个人,A走一段后,让给B,B用完继续给A ,交替使用,目的是提高效率。
区别:
并行是从微观上,也就是在一个精确的时间片刻,有不同的程序在执行,这就要求必须有多个处理器。
并发是从宏观上,在一个时间段上可以看出是同时执行的,比如一个服务器同时处理多个session。
5.同步异步阻塞非阻塞
在了解其他概念之前,我们首先要了解进程的几个状态。在程序运行的过程中,由于被操作系统的调度算法控制,程序会进入几个状态:就绪,运行和阻塞。
(1)就绪(Ready)状态
当进程已分配到除CPU以外的所有必要的资源,只要获得处理机便可立即执行,这时的进程状态称为就绪状态。
(2)执行/运行(Running)状态当进程已获得处理机,其程序正在处理机上执行,此时的进程状态称为执行状态。
(3)阻塞(Blocked)状态正在执行的进程,由于等待某个事件发生而无法执行时,便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种,例如,等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。
5.1 同步 异步
所谓同步就是一个任务的完成需要依赖另外一个任务时,只有等待被依赖的任务完成后,依赖的任务才能算完成,这是一种可靠的任务序列
。要么成功都成功,失败都失败,两个任务的状态可以保持一致。
所谓异步是不需要等待被依赖的任务完成,只是通知被依赖的任务要完成什么工作,依赖的任务也立即执行,只要自己完成了整个任务就算完成了
。至于被依赖的任务最终是否真正完成,依赖它的任务无法确定,所以它是不可靠的任务序列
。
5.2 阻塞 非阻塞
阻塞和非阻塞这两个概念与程序(线程)等待消息通知(无所谓同步或者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序(线程)等待消息通知时的状态角度来说的
5.3 同步异步阻塞非阻塞
同步阻塞形式
效率最低。拿上面的例子来说,就是你专心排队,什么别的事都不做。
异步阻塞形式
如果在银行等待办理业务的人采用的是异步的方式去等待消息被触发(通知),也就是领了一张小纸条,假如在这段时间里他不能离开银行做其它的事情,那么很显然,这个人被阻塞在了这个等待的操作上面;
异步操作是可以被阻塞住的,只不过它不是在处理消息时阻塞,而是在等待消息通知时被阻塞。
同步非阻塞形式
实际上是效率低下的。
想象一下你一边打着电话一边还需要抬头看到底队伍排到你了没有,如果把打电话和观察排队的位置看成是程序的两个操作的话,这个程序需要在这两种不同的行为之间来回的切换,效率可想而知是低下的。
异步非阻塞形式
效率更高
6. 进程的创建于结束
6.1 创建
但凡是硬件,都需要有操作系统去管理,只要有操作系统,就有进程的概念,就需要有创建进程的方式,一些操作系统只为一个应用程序设计,比如微波炉中的控制器,一旦启动微波炉,所有的进程都已经存在。
而对于通用系统(跑很多应用程序),需要有系统运行过程中创建或撤销进程的能力,主要分为4中形式创建新的进程:
1. 系统初始化(查看进程linux中用ps命令,windows中用任务管理器,前台进程负责与用户交互,后台运行的进程与用户无关,运行在后台并且只在需要时才唤醒的进程,称为守护进程,如电子邮件、web页面、新闻、打印)
2. 一个进程在运行过程中开启了子进程(如nginx开启多进程,os.fork,subprocess.Popen等)
3. 用户的交互式请求,而创建一个新进程(如用户双击暴风影音)
4. 一个批处理作业的初始化(只在大型机的批处理系统中应用)
无论哪一种,新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的。
6.2 结束
1. 正常退出(自愿,如用户点击交互式页面的叉号,或程序执行完毕调用发起系统调用正常退出,在linux中用exit,在windows中用ExitProcess)
2. 出错退出(自愿,python a.py中a.py不存在)
3. 严重错误(非自愿,执行非法指令,如引用不存在的内存,1/0等,可以捕捉异常,try...except...)
4. 被其他进程杀死(非自愿,如kill -9)
二、在python程序中的进程操作
1. multiprocess模块
multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多,为了方便大家归类记忆,我将这部分大致分为四个部分:创建进程部分,进程同步部分,进程池部分,进程之间数据共享。
2.multiprocess.process模块
process模块是一个创建进程的模块,借助这个模块,就可以完成进程的创建。
1 Process([group [, target [, name [, args [, kwargs]]]]]),由该类实例化得到的对象,表示一个子进程中的任务(尚未启动) 2 3 强调: 4 1. 需要使用关键字的方式来指定参数 5 2. args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号 6 7 参数介绍: 8 1 group参数未使用,值始终为None 9 2 target表示调用对象,即子进程要执行的任务 10 3 args表示调用对象的位置参数元组,args=(1,2,'egon',) 11 4 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18} 12 5 name为子进程的名称
1 1 p.start():启动进程,并调用该子进程中的p.run() 2 2 p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法 3 3 p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁 4 4 p.is_alive():如果p仍然运行,返回True 5 5 p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程
1 1 p.daemon:默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置 2 2 p.name:进程的名称 3 3 p.pid:进程的pid 4 4 p.exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可) 5 5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)
1 在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制),在创建子进程的时候会自动 import 启动它的这个文件,而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来,import 的时候 ,就不会递归运行了。
3.使用process模块创建进程
在一个python进程中开启子进程,start方法和并发效果。
1 import time 2 from multiprocessing import Process 3 4 def f(name): 5 print('hello', name) 6 print('我是子进程') 7 8 if __name__ == '__main__': 9 p = Process(target=f, args=('bob',)) 10 p.start() 11 time.sleep(1) 12 print('执行主进程的内容了')
1 import time 2 from multiprocessing import Process 3 4 def f(name): 5 print('hello', name) 6 time.sleep(1) 7 print('我是子进程') 8 9 10 if __name__ == '__main__': 11 p = Process(target=f, args=('bob',)) 12 p.start() 13 #p.join() 14 print('我是父进程')
1 import os 2 from multiprocessing import Process 3 4 def f(x): 5 print('子进程id :',os.getpid(),'父进程id :',os.getppid()) 6 return x*x 7 8 if __name__ == '__main__': 9 print('主进程id :', os.getpid()) 10 p_lst = [] 11 for i in range(5): 12 p = Process(target=f, args=(i,)) 13 p.start()
进阶,多个进程同时运行(注意,子进程的执行顺序不是根据启动顺序决定的)
1 import time 2 from multiprocessing import Process 3 4 5 def f(name): 6 print('hello', name) 7 time.sleep(1) 8 9 10 if __name__ == '__main__': 11 p_lst = [] 12 for i in range(5): 13 p = Process(target=f, args=('bob',)) 14 p.start()
1 import time 2 from multiprocessing import Process 3 4 5 def f(name): 6 print('hello', name) 7 time.sleep(1) 8 9 10 if __name__ == '__main__': 11 p_lst = [] 12 for i in range(5): 13 p = Process(target=f, args=('bob',)) 14 p.start() 15 p_lst.append(p) 16 p.join() 17 # [p.join() for p in p_lst] 18 print('父进程在执行')
1 import time 2 from multiprocessing import Process 3 4 def f(name): 5 print('hello', name) 6 time.sleep(1) 7 8 if __name__ == '__main__': 9 p_lst = [] 10 for i in range(5): 11 p = Process(target=f, args=('bob',)) 12 p.start() 13 p_lst.append(p) 14 # [p.join() for p in p_lst] 15 print('父进程在执行')
除了上面这些开启进程的方法,还有一种以继承Process类的形式开启进程的方式
1 import os 2 from multiprocessing import Process 3 4 5 class MyProcess(Process): 6 def __init__(self,name): 7 super().__init__() 8 self.name=name 9 def run(self): 10 print(os.getpid()) 11 print('%s 正在和女主播聊天' %self.name) 12 13 p1=MyProcess('wupeiqi') 14 p2=MyProcess('yuanhao') 15 p3=MyProcess('nezha') 16 17 p1.start() #start会自动调用run 18 p2.start() 19 # p2.run() 20 p3.start() 21 22 23 p1.join() 24 p2.join() 25 p3.join() 26 27 print('主线程')
1 from multiprocessing import Process 2 3 def work(): 4 global n 5 n=0 6 print('子进程内: ',n) 7 8 9 if __name__ == '__main__': 10 n = 100 11 p=Process(target=work) 12 p.start() 13 print('主进程内: ',n)
4,守护进程
会随着主进程的结束而结束。
主进程创建守护进程
其一:守护进程会在主进程代码执行结束后就终止
其二:守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes are not allowed to have children
注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止
1 import os 2 import time 3 from multiprocessing import Process 4 5 class Myprocess(Process): 6 def __init__(self,person): 7 super().__init__() 8 self.person = person 9 def run(self): 10 print(os.getpid(),self.name) 11 print('%s正在和女主播聊天' %self.person) 12 13 14 p=Myprocess('哪吒') 15 p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行 16 p.start() 17 time.sleep(10) # 在sleep时查看进程id对应的进程ps -ef|grep id 18 print('主')
1 from multiprocessing import Process 2 3 def foo(): 4 print(123) 5 time.sleep(1) 6 print("end123") 7 8 def bar(): 9 print(456) 10 time.sleep(3) 11 print("end456") 12 13 14 p1=Process(target=foo) 15 p2=Process(target=bar) 16 17 p1.daemon=True 18 p1.start() 19 p2.start() 20 time.sleep(0.1) 21 print("main-------")#打印该行则主进程代码结束,则守护进程p1应该被终止.#可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止.
5.socket聊天并发实例
1 from socket import * 2 from multiprocessing import Process 3 4 server=socket(AF_INET,SOCK_STREAM) 5 server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) 6 server.bind(('127.0.0.1',8080)) 7 server.listen(5) 8 9 def talk(conn,client_addr): 10 while True: 11 try: 12 msg=conn.recv(1024) 13 if not msg:break 14 conn.send(msg.upper()) 15 except Exception: 16 break 17 18 if __name__ == '__main__': #windows下start进程一定要写到这下面 19 while True: 20 conn,client_addr=server.accept() 21 p=Process(target=talk,args=(conn,client_addr)) 22 p.start()
1 from socket import * 2 3 client=socket(AF_INET,SOCK_STREAM) 4 client.connect(('127.0.0.1',8080)) 5 6 7 while True: 8 msg=input('>>: ').strip() 9 if not msg:continue 10 11 client.send(msg.encode('utf-8')) 12 msg=client.recv(1024) 13 print(msg.decode('utf-8'))
6.其他方法
1 from multiprocessing import Process 2 import time 3 import random 4 5 class Myprocess(Process): 6 def __init__(self,person): 7 self.name=person 8 super().__init__() 9 10 def run(self): 11 print('%s正在和网红脸聊天' %self.name) 12 time.sleep(random.randrange(1,5)) 13 print('%s还在和网红脸聊天' %self.name) 14 15 16 p1=Myprocess('哪吒') 17 p1.start() 18 19 p1.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活 20 print(p1.is_alive()) #结果为True 21 22 print('开始') 23 print(p1.is_alive()) #结果为False
1 class Myprocess(Process): 2 def __init__(self,person): 3 self.name=person # name属性是Process中的属性,标示进程的名字 4 super().__init__() # 执行父类的初始化方法会覆盖name属性 5 #self.name = person # 在这里设置就可以修改进程名字了 6 #self.person = person #如果不想覆盖进程名,就修改属性名称就可以了 7 def run(self): 8 print('%s正在和网红脸聊天' %self.name) 9 # print('%s正在和网红脸聊天' %self.person) 10 time.sleep(random.randrange(1,5)) 11 print('%s正在和网红脸聊天' %self.name) 12 # print('%s正在和网红脸聊天' %self.person) 13 14 15 p1=Myprocess('哪吒') 16 p1.start() 17 print(p1.pid) #可以查看子进程的进程id
三、进程同步(multiprocess.Lock、multiprocess.Semaphore、multiprocess.Event)
3.1 锁
1 #文件db的内容为:{"count":5} 2 #注意一定要用双引号,不然json无法识别 3 #并发运行,效率高,但竞争写同一文件,数据写入错乱 4 from multiprocessing import Process,Lock 5 import time,json,random 6 def search(): 7 dic=json.load(open('db')) 8 print('