进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。

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

第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为进程。[3] 进程是操作系统中最基本、重要的概念。是多道程序系统出现后，为了刻画系统内部出现的动态情况，描述系统内部各道程序的活动规律引进的一个概念,所有多道程序设计操作系统都建立在进程的基础上。

操作系统引入进程的概念的原因 从理论角度看，是对正在运行的程序过程的抽象；从实现角度看，是一种数据结构，目的在于清晰地刻画动态系统的内在规律，有效管理和调度进入计算机系统主存储器运行的程序。

程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。而进程是程序在处理机上的一次执行过程，它是一个动态的概念。程序可以作为一种软件资料长期存在，而进程是有一定生命期的。程序是永久的，进程是暂时的。

进程的并行与并发

并行 : 并行是指两者同时执行，比如赛跑，两个人都在不停的往前跑；（资源够用，比如三个线程，四核的CPU ）

并发 : 并发是指资源有限的情况下，两者交替轮流使用资源，比如一段路(单核CPU资源)同时只能过一个人，A走一段后，让给B，B用完继续给A ，交替使用，目的是提高效率。

区别:

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

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

状态介绍

在了解其他概念之前，我们首先要了解进程的几个状态。在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞。

　　（1）就绪(Ready)状态

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

　　（2）执行/运行（Running）状态当进程已获得处理机，其程序正在处理机上执行，此时的进程状态称为执行状态。

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

 

同步和异步

所谓同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。

　　所谓异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。至于被依赖的任务最终是否真正完成，依赖它的任务无法确定，所以它是不可靠的任务序列。

阻塞与非阻塞

阻塞和非阻塞这两个概念与程序（线程）等待消息通知(无所谓同步或者异步)时的状态有关。也就是说阻塞与非阻塞主要是程序（线程）等待消息通知时的状态角度来说的

进程的创建

但凡是硬件，都需要有操作系统去管理，只要有操作系统，就有进程的概念，就需要有创建进程的方式，一些操作系统只为一个应用程序设计，比如微波炉中的控制器，一旦启动微波炉，所有的进程都已经存在。

　　而对于通用系统（跑很多应用程序），需要有系统运行过程中创建或撤销进程的能力，主要分为4中形式创建新的进程：

　　1. 系统初始化（查看进程linux中用ps命令，windows中用任务管理器，前台进程负责与用户交互，后台运行的进程与用户无关，运行在后台并且只在需要时才唤醒的进程，称为守护进程，如电子邮件、web页面、新闻、打印）

　　2. 一个进程在运行过程中开启了子进程（如nginx开启多进程，os.fork,subprocess.Popen等）

　　3. 用户的交互式请求，而创建一个新进程（如用户双击暴风影音）

　　4. 一个批处理作业的初始化（只在大型机的批处理系统中应用）

进程的结束

1. 正常退出（自愿，如用户点击交互式页面的叉号，或程序执行完毕调用发起系统调用正常退出，在linux中用exit，在windows中用ExitProcess）

　　2. 出错退出（自愿，python a.py中a.py不存在）

　　3. 严重错误（非自愿，执行非法指令，如引用不存在的内存，1/0等，可以捕捉异常，try...except...）

　　4. 被其他进程杀死（非自愿，如kill -9）

multiprocess模块

仔细说来，multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，我将这部分大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。

multiprocess.process模块

process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）强调：1. 需要使用关键字的方式来指定参数2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号参数介绍：1 group参数未使用，值始终为None2 target表示调用对象，即子进程要执行的任务3 args表示调用对象的位置参数元组，args=(1,2,'egon',)4 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}5 name为子进程的名称 方法介绍：

1 p.start()：启动进程，并调用该子进程中的p.run() 2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  3 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁4 p.is_alive():如果p仍然运行，返回True5 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程  属性介绍

p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置2 p.name:进程的名称3 p.pid：进程的pid4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可） 在windows中使用process模块的注意事项

在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来，import 的时候  ，就不会递归运行了。

使用process模块创建进程

在python中启动的第一个子进程

import timefrom multiprocessing import Processdef f(name):    print('hello', name)    print('我是子进程')if __name__ == '__main__':    p = Process(target=f, args=('bob',))    p.start()    time.sleep(1)    print('执行主进程的内容了') join方法

import timefrom multiprocessing import Processdef f(name):    print('hello', name)    time.sleep(1)    print('我是子进程')if __name__ == '__main__':    p = Process(target=f, args=('bob',))    p.start()    #p.join()    print('我是父进程') 查看主进程和子进程的进程号

import osfrom multiprocessing import Processdef f(x):    print('子进程id ：',os.getpid(),'父进程id ：',os.getppid())    return x*xif __name__ == '__main__':    print('主进程id ：', os.getpid())    p_lst = []    for i in range(5):        p = Process(target=f, args=(i,))        p.start()

进阶，多个进程同时运行（注意，子进程的执行顺序不是根据启动顺序决定的） 多个进程同时运行

import timefrom multiprocessing import Processdef f(name):    print('hello', name)    time.sleep(1)if __name__ == '__main__':    p_lst = []    for i in range(5):        p = Process(target=f, args=('bob',))        p.start()        p_lst.append(p) 多个进程同时运行，再谈join方法(1)

import timefrom multiprocessing import Processdef f(name):    print('hello', name)    time.sleep(1)if __name__ == '__main__':    p_lst = []    for i in range(5):        p = Process(target=f, args=('bob',))        p.start()        p_lst.append(p)        p.join()    # [p.join() for p in p_lst]    print('父进程在执行')

守护进程

会随着主进程的结束而结束。

主进程创建守护进程

　　其一：守护进程会在主进程代码执行结束后就终止

　　其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children

注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止

守护进程的启动

import osimport timefrom multiprocessing import Processclass Myprocess(Process):    def __init__(self,person):        super().__init__()        self.person = person    def run(self):        print(os.getpid(),self.name)        print('%s正在和女主播聊天' %self.person)p=Myprocess('哪吒')p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行p.start()time.sleep(10) # 在sleep时查看进程id对应的进程ps -ef|grep idprint('主') 主进程代码执行结束守护进程立即结束

from multiprocessing import Processdef foo():    print(123)    time.sleep(1)    print("end123")def bar():    print(456)    time.sleep(3)    print("end456")p1=Process(target=foo)p2=Process(target=bar)p1.daemon=Truep1.start()p2.start()time.sleep(0.1)print("main-------")#打印该行则主进程代码结束,则守护进程p1应该被终止.#可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止. 通过继承Process类开启进程

import osfrom multiprocessing import Processclass MyProcess(Process):    def __init__(self,name):        super().__init__()        self.name=name    def run(self):        print(os.getpid())        print('%s 正在和女主播聊天' %self.name)p1=MyProcess('wupeiqi')p2=MyProcess('yuanhao')p3=MyProcess('nezha')p1.start() #start会自动调用runp2.start()# p2.run()p3.start()p1.join()p2.join()p3.join()print('主线程') 进程之间的数据隔离问题

from multiprocessing import Processdef work():    global n    n=0    print('子进程内: ',n)if __name__ == '__main__':    n = 100    p=Process(target=work)    p.start()    print('主进程内: ',n)

进程对象的其他方法:terminate,is_alive

from multiprocessing import Processimport timeimport randomclass Myprocess(Process):    def __init__(self,person):        self.name=person        super().__init__()    def run(self):        print('%s正在和网红脸聊天' %self.name)        time.sleep(random.randrange(1,5))        print('%s还在和网红脸聊天' %self.name)p1=Myprocess('哪吒')p1.start()p1.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活print(p1.is_alive()) #结果为Trueprint('开始')print(p1.is_alive()) #结果为False 进程对象的其他属性:pid和name

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

使用锁维护执行顺序

# 由并发变成了串行,牺牲了运行效率,但避免了竞争import osimport timeimport randomfrom multiprocessing import Process,Lockdef work(lock,n):    lock.acquire()    print('%s: %s is running' % (n, os.getpid()))    time.sleep(random.random())    print('%s: %s is done' % (n, os.getpid()))    lock.release()if __name__ == '__main__':    lock=Lock()    for i in range(3):        p=Process(target=work,args=(lock,i))        p.start() 使用锁来保证数据安全

#文件db的内容为：{"count":5}#注意一定要用双引号，不然json无法识别#并发运行，效率高，但竞争写同一文件，数据写入错乱from multiprocessing import Process,Lockimport time,json,randomdef search():    dic=json.load(open('db'))    print('\033[43m剩余票数%s\033[0m' %dic['count'])def get():    dic=json.load(open('db'))    time.sleep(random.random()) #模拟读数据的网络延迟    if dic['count'] >0:        dic['count']-=1        time.sleep(random.random()) #模拟写数据的网络延迟        json.dump(dic,open('db','w'))        print('\033[32m购票成功\033[0m')    else:        print('\033[31m购票失败\033[0m')def task(lock):    search()    lock.acquire()    get()    lock.release()if __name__ == '__main__':    lock = Lock()    for i in range(100): #模拟并发100个客户端抢票        p=Process(target=task,args=(lock,))        p.start()

进程间通信

IPC(Inter-Process Communication)

队列 

创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

Queue([maxsize]) 创建共享的进程队列。参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。底层队列使用管道和锁定实现。 子进程发送数据给父进程

import timefrom multiprocessing import Process, Queuedef f(q):    q.put([time.asctime(), 'from Eva', 'hello'])  #调用主函数中p进程传递过来的进程参数 put函数为向队列中添加一条数据。if __name__ == '__main__':    q = Queue() #创建一个Queue对象    p = Process(target=f, args=(q,)) #创建一个进程    p.start()    print(q.get())    p.join()