python枪战_python 进程

一. 什么是进程

狭义定义 : 进程是正在运行的程序的实例.

广义定义 : 进程(Process)是计算机中的程序关于某数据集合上的一次运动活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础. 它是操作系统执行的基本单元,在传统的操作系统中,进程即是基本的分配单元,也是基本的执行单元.

进程是一个实体,每一个进程都有它自己的地址空间,一般情况下,包括文本区域,数据区域和堆栈.文本区域存储处理器执行的代码,数据区域存储变量和进程执行期间使用的动态分配的内存,堆栈区域存储着活动过程调用的指令和本地变量.

进程是一个'执行中的程序'. 程序时一个没有生命的实体,只有处理器赋予程序生命时|(操作系统去执行),它才能成为一个活动的实体,我们称之为进程

进程是操作系统中最基本,重要的概念. 进程可以使同一台服务器处理多个任务,有效的调度和管理计算机系统运行的程序.(操作系统引入进程概念的原因)

一个进程只能处理一个任务,想处理多个任务需要开启多进程.

二. 进程的特征

1. 动态性 : 进程的实质是在多道程序中系统的一次执行过程,晋城市动态产生,动态消亡的

2. 并发性 : 任何进程都可以和其他程序并发执行

3. 独立性 : 进程是一个可以独立运行的基本单位,同时也是系统进行资源分配和调度的独立单位

4. 异步性 : 由于进程之间的相互制约,使进程具有执行的间断性(即进程按各自独立,不可预知的速度向前推进)

5. 结构特征 : 进程由代码块,数据块,PCB(进程控制块)三部分组成

6. 多个不同的进程可以包含相同的程序 : 一个程序在不同的数据集里就构成不同的进程,能得到不同的结果,但是执行过程中,程序不能发生改变.

同一个程序执行两次,操作系统中就会出现两个进程,所以我们可以同时运行一个软件,分别去做不同的事情

三. 进程和程序的区别

1. 程序时指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念.

2. 进程是程序在处理机上的一次执行过程,它是一个动态的概念

3. 程序可以作为一种软件资料长期存在,而进程是有一定生命期的(程序时永久的,进程是暂时的)

4. 正常情况下,多进程之间无法进行通信,因为每一个进程都有一个独立的内存空间.

四. 进程调度

1. 先来先服务(FCFS) :

该算法既可以用于作业调度,也可以用于进程调度. FCFS算法比较有利于长作业(进程),而不利于短作业(进程). 也就是适合于CPU繁忙性作业

2. 短作业优先调度 :

短作业(进程)优先调度算法是指对短作业或短进程优先调度的算法,该算法既可用于作业调度,也可以用于进程调度. 但对长作业不利,不能保证紧迫性作业被及时处理.

3. 时间片论转 :

在时间片轮转法中,需要将CPU的处理时间分成固定大小的时间片. 如果一个进程在被调度选中后用完了规定的时间,但是任务还没有完成,就需要将所占用的资源释放而且重新再就绪队列的末尾进行排队,等待下一个调度,进程则去调度当前就绪队列中的第一个进程

4. 多级反馈队列 :

此方法设置多个不同优先级的就绪队列第一个队列的优先级最高,依次向下. 该算法赋予各个队列进程执行时间片大小也不同, 优先级别越高,规定的进程执行时间片越小.

当一个新进程进入内存后,会将它放入第一队列的末尾,按FCFS原则排队,当轮到它执行时,若它在规定时间片内执行完毕,则退出系统.如果没有执行完,则调度算法便将该进程转入第二队列的末尾,执行顺序和第一队列相同,如果在此队列还未完成程序,则进入下一队列末尾.依次循环

仅当第一队列空闲时,调度程序才会调度第二队列的进程运行. 只有第n个的之前的所有队列中的全部空闲时,才会调度第n个队列中的进程执行. 如果处理机正在第n个队列为某进程服务,又有新进程进入了优先权更高的队列,则此时新进程将会枪战正在运行的进程处理机,即房下当前执行的进程,去执行优先级别更高的进程.

五. 进程的并行和并发

并行 : 并行是指两者同时执行

并行是从微观上, 也就是在一个准确的时间片刻,有不同的程序在执行,这就要求必须要有多个处理器

并发 : 并发是指资源有限的情况下,两者交替轮流使用资源.目的在此基础上提高效率

并发从宏观上, 在一个时间段上可以看出是同时执行的 , 比如一个处理器同时处理多个任务

六. 同步异步,阻塞非阻塞

进程三种状态 :

就绪状态 : 进程分配到除CPU以外的其他所有资源

执行状态 : 进程获得所有资源,处于正在执行的状态

阻塞状态 : 由于某些事情的发生而无法执行,进程放弃了处理机而处于阻塞状态. (用户输入; time.sleep)

同步异步 :

同步 : 所谓同步就是一个任务的完成需要依赖另一个任务的完成. 只有被依赖的任务完成了,以来的任务才能完成. 就是如果完成,两个任务都完成,否则就都不能完成

异步 : 异步就是不需要等待被依赖的任务完成,只是通知被依赖的任务要完成什么工作,依赖的任务仍然可以继续执行,只要自己完成就完成.被依赖的任务是否完成,依赖的任务是无法确定的.

阻塞 : 如果在调用的时候,被卡住,不能再继续向下运行,需要等待,就是阻塞

非阻塞 : 如果在调用时候,没有被卡住,可以继续向下执行,就是非阻塞

同步阻塞 : 效率最低

异步阻塞 : 异步阻塞不是在处理是阻塞, 而是在等待处理时被阻塞.

七. 进程的创建与结束

multiprocess模块 : 其实multiprocess不是一个模块而是一个包. 这个包中集合包含了和进程有关的所有子模块.

multiprocess.process模块 : process模块是一个创建进程的模块.

进程的两种创建方法 : ① . p = Process( target = None , args = (参数为元组类型))

参数介绍 :

1. target : 是进程实例化对象要调用的子进程名

2. args : 是父类进程给子类进程传递的参数

② . 自定义类,继承Process类

进程的常用属性 :

p.name = 　　#给p进程一个名字

p.pid　　#返回p进程的pid

p.daemon = True　　#将p进程设置为守护进程(True为守护进程,False为普通进程)

from multiprocessing importProcessimportosdeffunc():print('这里是儿子,儿子的pid是%s'%(os.getpid()))if __name__ == '__main__':

p= Process(target=func)

p.start()

p.name= 'a'#给子进程命名

print('儿子的名字是%s'%p.name)print('儿子的pid是%s'%p.pid)print('儿子是不是守护进程？',p.daemon)

进程的常用方法 :

start()　　#开启一个进程(告诉操作系统,帮我开启一个进程,由操作系统去执行),底层自动调用p.run()方法.

join()　　#异步变同步(就是让父(主)进程停留在join,等待子进程结束,父进程再继续执行)

is_alive()　　#判断进程是否活着

terminate()　　#杀死进程

from multiprocessing importProcessclassA(Process):def __init__(self):

super().__init__()defrun(self):print('突然好想你,你会在哪里,过得快乐或委屈')if __name__ == '__main__':

p=A()

p.start()#开启一个子进程,自动执行进程中的run方法

p.terminate()#告诉操作系统,请帮我杀死进程

print('子进程是否还活着?', p.is_alive())#相对于主进程的执行速度,杀死过程会比较慢,所以这里还会显示True.如果执行此代码前阻塞一定时间,显示会正常

print('突然好想你')

os.getpid()　　#查看当前进程的pid

os.getppid()　　#查看当前进程的父进程的pid

from multiprocessing importProcessimportosdeffunc():print('这是子进程的pid %s . 主进程的pid %s' %(os.getpid(),os.getppid()))if __name__ == '__main__':

p= Process(target=func)

p.start()print('这是主进程的pid %s' % os.getpid())

八. 守护进程

守护进程特点 :

1. 守护进程会随着父进程代码块的结束而结束

2. 守护进程不能创建子进程

from multiprocessing importProcessimporttimedeffunc():for i in range(10):

time.sleep(1)print(time.strftime('%H:%M:%S'))if __name__ == '__main__':

p= Process(target=func)

p.daemon= True #将p进程设置为守护进程,必须要在start之前设置

p.start()

time.sleep(5)print('这是父进程')

九. 多进程

创建多进程

from multiprocessing importProcessdeffunc(i):print('这里是子进程%s'%i)if __name__ == '__main__':for i in range(5):

p= Process(target=func,args=(i,))

p.start()

from multiprocessing importProcessdeffunc(i):print('这里是子进程%s'%i)if __name__ == '__main__':

lst=[]for i in range(5):

p= Process(target=func,args=(i,))

p.start()

lst.append(p)

[s.join()for s in lst]#异步变同步

print('这里是父进程')