python 进程介绍 进程简单使用 join 验证空间隔离

时间:2021-08-19 11:19:50

一、多道程序设计技术(详情参考:https://www.cnblogs.com/clschao/articles/9613464.html)

  所谓多道程序设计技术,就是指允许多个程序同时进入内存并运行。即同时把多个程序放入内存,并允许它们交替在CPU中运行,它们共享系统中的各种硬、软件资源。当一道程序因I/O请求而暂停运行时,CPU便立即转去运行另一道程序。

python 进程介绍 进程简单使用 join 验证空间隔离

  在A程序计算时,I/O空闲, A程序I/O操作时,CPU空闲(B程序也是同样);必须A工作完成后,B才能进入内存中开始工作,两者是串行的,全部完成共需时间=T1+T2。

python 进程介绍 进程简单使用 join 验证空间隔离

  将A、B两道程序同时存放在内存中,它们在系统的控制下,可相互穿插、交替地在CPU上运行:当A程序因请求I/O操作而放弃CPU时,B程序就可占用CPU运行,这样 CPU不再空闲,而正进行A I/O操作的I/O设备也不空闲,显然,CPU和I/O设备都处于“忙”状态,大大提高了资源的利用率,从而也提高了系统的效率,A、B全部完成所需时间<<T1+T2。

  多道程序设计技术不仅使CPU得到充分利用,同时改善I/O设备和内存的利用率,从而提高了整个系统的资源利用率和系统吞吐量(单位时间内处理作业(程序)的个数),最终提高了整个系统的效率。

  单处理机系统中多道程序运行时的特点:

  (1)多道:计算机内存中同时存放几道相互独立的程序;
  (2)宏观上并行:同时进入系统的几道程序都处于运行过程中,即它们先后开始了各自的运行,但都未运行完毕;
  (3)微观上串行:实际上,各道程序轮流地用CPU,并交替运行。
  空间上的复用:将内存分为几部分,每个部分放入一个程序,这样,同一时间内存中就有了多道程序。

  python 进程介绍 进程简单使用 join 验证空间隔离

  时间上的复用:当一个程序在等待I/O时,另一个程序可以使用cpu,如果内存中可以同时存放足够多的作业,则cpu的利用率可以接近100%

二、分时系统

  由于CPU速度不断提高和采用分时技术,一台计算机可同时连接多个用户终端,而每个用户可在自己的终端上联机使用计算机,好象自己独占机器一样。

  分时技术:把处理机的运行时间分成很短的时间片,按时间片轮流把处理机分配给各联机作业使用。

  若某个作业在分配给它的时间片内不能完成其计算,则该作业暂时中断,把处理机让给另一作业使用,等待下一轮时再继续其运行。由于计算机速度很快,作业运行轮转得很快,给每个用户的印象是,好象他独占了一台计算机。而每个用户可以通过自己的终端向系统发出各种操作控制命令,在充分的人机交互情况下,完成作业的运行。
具有上述特征的计算机系统称为分时系统,它允许多个用户同时联机使用计算机。
  特点:
  (1)多路性。若干个用户同时使用一台计算机。微观上看是各用户轮流使用计算机;宏观上看是各用户并行工作。
  (2)交互性。用户可根据系统对请求的响应结果,进一步向系统提出新的请求。这种能使用户与系统进行人机对话的工作方式,明显地有别于批处理系统,因而,分时系统又被称为交互式系统。
  (3)独立性。用户之间可以相互独立操作,互不干扰。系统保证各用户程序运行的完整性,不会发生相互混淆或破坏现象。
  (4)及时性。系统可对用户的输入及时作出响应。分时系统性能的主要指标之一是响应时间,它是指:从终端发出命令到系统予以应答所需的时间。
  分时系统的主要目标:对用户响应的及时性,即不至于用户等待每一个命令的处理时间过长。
  分时系统可以同时接纳数十个甚至上百个用户,由于内存空间有限,往往采用对换(又称交换)方式的存储方法。即将未“轮到”的作业放入磁盘,一旦“轮到”,再将其调入内存;而时间片用完后,又将作业存回磁盘(俗称“滚进”、“滚出“法),使同一存储区域轮流为多个用户服务。
多用户分时系统是当今计算机操作系统中最普遍使用的一类操作系统。
  注意:分时系统的分时间片工作,在没有遇到IO操作的时候就用完了自己的时间片被切走了,这样的切换工作其实并没有提高cpu的效率,反而使得计算机的效率降低了。为什么下降了呢?因为CPU需要切换,并且记录每次切换程序执行到了哪里,以便下次再切换回来的时候能够继续之前的程序,虽然我们牺牲了一点效率,但是却实现了多个程序共同执行的效果,这样你就可以在计算机上一边听音乐一边聊qq了。

三、进程 (详情参考:https://www.cnblogs.com/clschao/articles/9629392.html?tdsourcetag=s_pctim_aiomsg)

  1、进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。

  (在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。我们自己在python文件中写了一些代码,这叫做程序,运行这个python文件的时候,这叫做进程。)

  2、狭义定义:进程是正在运行的程序的实例(an instance of a computer program that is being executed)。

    广义定义:进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元,在传统的操作系统中,进程既是基本的分配单元,也是基本的执行单元。

  3、进程的六大特征

动态性:进程的实质是程序在多道程序系统中的一次执行过程,进程是动态产生,动态消亡的。
并发性:任何进程都可以同其他进程一起并发执行
独立性:进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位;
异步性:由于进程间的相互制约,使进程具有执行的间断性,即进程按各自独立的、不可预知的速度向前推进
结构特征:进程由程序、数据和进程控制块三部分组成。
多个不同的进程可以包含相同的程序:一个程序在不同的数据集里就构成不同的进程,能得到不同的结果;但是执行过程中,程序不能发生改变。

六大特征

  程序是静止的永久的,而进程是暂时的。

  4、进程调度:要想多个进程交替运行,操作系统必须对这些进程进行调度,这个调度也不是随即进行的,而是需要遵循一定的法则,由此就有了进程的调度算法。

    进程调度由操作系统完成。

四、进程调度

  要想多个进程交替运行,操作系统必须对这些进程进行调度,这个调度也不是随即进行的,而是需要遵循一定的法则,由此就有了进程的调度算法。

先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。FCFS算法比较有利于长作业(进程),而不利于短作业(进程)。由此可知,本算法适合于CPU繁忙型作业,而不利于I/O繁忙型的作业(进程)。

先来先服务调度算法

短作业(进程)优先调度算法(SJ/PF)是指对短作业或短进程优先调度的算法,该算法既可用于作业调度,也可用于进程调度。但其对长作业不利;不能保证紧迫性作业(进程)被及时处理;作业的长短只是被估算出来的。

短作业优先调度算法

时间片轮转(Round Robin,RR)法的基本思路是让每个进程在就绪队列中的等待时间与享受服务的时间成比例。在时间片轮转法中,需要将CPU的处理时间分成固定大小的时间片,例如,几十毫秒至几百毫秒。如果一个进程在被调度选中之后用完了系统规定的时间片,但又未完成要求的任务,则它自行释放自己所占有的CPU而排到就绪队列的末尾,等待下一次调度。同时,进程调度程序又去调度当前就绪队列中的第一个进程。
显然,轮转法只能用来调度分配一些可以抢占的资源。这些可以抢占的资源可以随时被剥夺,而且可以将它们再分配给别的进程。CPU是可抢占资源的一种。但打印机等资源是不可抢占的。由于作业调度是对除了CPU之外的所有系统硬件资源的分配,其中包含有不可抢占资源,所以作业调度不使用轮转法。
在轮转法中,时间片长度的选取非常重要。首先,时间片长度的选择会直接影响到系统的开销和响应时间。如果时间片长度过短,则调度程序抢占处理机的次数增多。这将使进程上下文切换次数也大大增加,从而加重系统开销。反过来,如果时间片长度选择过长,例如,一个时间片能保证就绪队列中所需执行时间最长的进程能执行完毕,则轮转法变成了先来先服务法。时间片长度的选择是根据系统对响应时间的要求和就绪队列中所允许最大的进程数来确定的。
在轮转法中,加入到就绪队列的进程有3种情况:
一种是分给它的时间片用完,但进程还未完成,回到就绪队列的末尾等待下次调度去继续执行。
另一种情况是分给该进程的时间片并未用完,只是因为请求I/O或由于进程的互斥与同步关系而被阻塞。当阻塞解除之后再回到就绪队列。
第三种情况就是新创建进程进入就绪队列。
如果对这些进程区别对待,给予不同的优先级和时间片从直观上看,可以进一步改善系统服务质量和效率。例如,我们可把就绪队列按照进程到达就绪队列的类型和进程被阻塞时的阻塞原因分成不同的就绪队列,每个队列按FCFS原则排列,各队列之间的进程享有不同的优先级,但同一队列内优先级相同。这样,当一个进程在执行完它的时间片之后,或从睡眠中被唤醒以及被创建之后,将进入不同的就绪队列。

时间轮片调度

前面介绍的各种用作进程调度的算法都有一定的局限性。如短进程优先的调度算法,仅照顾了短进程而忽略了长进程,而且如果并未指明进程的长度,则短进程优先和基于进程长度的抢占式调度算法都将无法使用。
而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间,而且还可以满足各种类型进程的需要,因而它是目前被公认的一种较好的进程调度算法。在采用多级反馈队列调度算法的系统中,调度算法的实施过程如下所述。
(1) 应设置多个就绪队列,并为各个队列赋予不同的优先级。第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同,在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小。例如,第二个队列的时间片要比第一个队列的时间片长一倍,……,第i+1个队列的时间片要比第i个队列的时间片长一倍。
(2) 当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度。当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业(进程)从第一队列依次降到第n队列后,在第n 队列便采取按时间片轮转的方式运行。 (3) 仅当第一队列空闲时,调度程序才调度第二队列中的进程运行;仅当第1~(i-1)队列均空时,才会调度第i队列中的进程运行。如果处理机正在第i队列中为某进程服务时,又有新进程进入优先权较高的队列(第1~(i-1)中的任何一个队列),则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第i队列的末尾,把处理机分配给新到的高优先权进程。

多级反馈调度

四、并发和并行

  通过进程之间的调度,也就是进程之间的切换,我们用户感知到的好像是两个视频文件同时在播放,或者音乐和游戏同时在进行,那就让我们来看一下什么叫做并发和并行

  并发:伪并行,即看起来是同时运行。单个cpu+多道技术就可以实现并发,(并行也属于并发)

  并行:同时运行,只有具备多个cpu才能实现并行

python 进程介绍 进程简单使用 join 验证空间隔离

五、同步、异步、阻塞、非阻塞(详情参考:https://www.cnblogs.com/clschao/articles/9629392.html?tdsourcetag=s_pctim_aiomsg)

  1、进程三态

python 进程介绍 进程简单使用 join 验证空间隔离

(1)就绪(Ready)状态

  当进程已分配到除CPU以外的所有必要的资源,只要获得处理机便可立即执行,这时的进程状态称为就绪状态。

(2)执行/运行(Running)状态

  当进程已获得处理机,其程序正在处理机上执行,此时的进程状态称为执行状态。

(3)阻塞(Blocked)状态

  正在执行的进程,由于等待某个事件发生而无法执行时,便放弃处理机而处于阻塞状态。引起进程阻塞的事件可有多种,例如,等待I/O完成、申请缓冲区不能满足、等待信件(信号)等。

六、python 进程

  1、创建进程的两种方法

方法一:

from multiprocessing import Process

#定义执行函数
def func1():
pass if __name__ == '__main__':
# p=Process(target=func1,args=(10,)) #位置传参
p=Process(target=func1,kwargs={"a":10,"b":20,})#关键字传参
from multiprocessing import Process
import time,os def func1():
time.sleep(2)
print("我是func1") def func2():
time.sleep(2)
print("子进程pid>>>",os.getpid())
print("子进程的父进程pid>>>", os.getppid())
print("我是func2") if __name__ == '__main__':
#查看当前进程pid
print("主进程pid>>>",os.getpid()) #查看主进程pid
print("主进程父进程pid>>>",os.getppid())#查看主程序父进程
start_time=time.time()
p=Process(target=func2)#创建进程
p.start() #就绪,告诉操作系统等待调度
func1()
end_time=time.time()
dif_time=end_time-start_time
print("时间差>>>",dif_time)

模块传参创建进程

方法二:

from multiprocessing import Process

# 方法二
class MyProcess(Process):
#引入Process中的属性
def __init__(self,n): #n为传入的参数
super().__init__()
pass if __name__ == '__main__': p=MyProcess(10)
p.start()
import time
from multiprocessing import Process class MyProcess(Process):
def __init__(self,n):
super().__init__()#引入父类的属性进行
self.n=n def run(self):
time.sleep(2)
print("传入的参数>>>",self.n)
print("我是类创建的进程") if __name__ == '__main__': p=MyProcess(10)
p.start()

类方法创建进程

  2、进程相关的功能

  os.getpid( )  表示获取进程的pid号

  os.getppid() 表示获取父进程的pid号

  p=Process(target= func1, args=( ,)) 创建一个进程p,执行函数为func1,函数参数为args

  p.start() 就绪,等待操作系统开启进程和执行进程

  p.join( ) 等待进程p执行完后,再继续执行

  p.terminate() 关闭进程,不会立即关闭,有个等待着操作系统去关闭这个进程的时间

  p.is_alive() 判断进程是否还存在,如果存在就返回True

  p.pid( ) 查看pid

  p.name() 查看pid名字

  3、join 实例

import time
from multiprocessing import Process def func1(n,m):
print('参数%s'%n)
print(m)
time.sleep(2)
print('我是func1') def func2():
time.sleep(3)
print('我是func2') if __name__ == '__main__':
p1 = Process(target=func1,args=(10,20,))
# p1 = Process(target=func1,kwargs={'n':10,'m':20})
p2 = Process(target=func2)
p1.start()
p2.start()
print('主进程运行到这里了')
p1.join() #等待1号子进程运行结束
p2.join()
print('主进程结束')

python 进程介绍 进程简单使用 join 验证空间隔离

  4、进程空间隔离验证

  思路:如果进程能对全局变量进行更改,就是进程空间不能隔离,否则就是进程空间隔离

from multiprocessing import Process

num = 20

def func():
global num
num = 10
print('子进程的num>>>>',num) if __name__ == '__main__': p = Process(target=func,)
p.start()
p.join()
print('主进程num:',num)