python 进程

一. 什么是进程

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

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

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

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

　　进程是操作系统中最基本,重要的概念. 是多道程序系统出现后,为了刻画系统内部出现的动态情况,描述系统内部割刀程序的活动规律引进的一个概念,所有多到程序设计操作系统都建立在进程的基础上.(操作系统引入进程概念的原因)

二. 进程的特征

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

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

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

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

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

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

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

三. 进程和程序的区别

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

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

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

四. 进程调度

　　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 import Process
import os
def func():
    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 import Process
class A(Process):
    def __init__(self):
        super().__init__()

    def run(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 import Process
import os

def func():
    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 import Process
import time

def func():
    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 import Process
def func(i):
    print(‘这里是子进程%s‘% i)

if __name__ == ‘__main__‘:
    for i in range(5):
        p = Process(target=func,args=(i,))
        p.start()

from multiprocessing import Process
def func(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(‘这里是父进程‘)

python 进程

原文：https://www.cnblogs.com/dong-/p/9506369.html