python之进程

进程：正在执行的一个过程，是对正在运行程序的一个抽象

进程的特征:

1.动态性 2.并发行 3.独立性 4.异步性 5.结构特征: 进程由程序,数据和进程控制块三部分组成

操作系统：推荐阅读《操作系统原理》 《现代操作系统》

IO操作(input, sleep, 文件输入输出, recv, accept等)

进程调度：多个进程交替运行，操作系统必须对这些进程进行调度，这个调度也不是随即进行的，而是需要遵循一定的法则。

1. 先来先服务调度法
2. 短作业优先调度法
3. 时间片论转法
4. 多级反馈队列

并发与并行

***多道程序系统（程序之间的切换运行，保存状态叫做并发（伪并行））

并行是理想状态，源于多个cpu运行(多核技术)

同步异步（任务的提交方式，异步：多个任务同时提交出去，同时执行）

同步/异步 与 阻塞(遇到I/O)和非阻塞

1. 同步阻塞形式（效率低，排队）
2. 异步阻塞形式 （异步操作是可以被阻塞的，只不过它不是在处理消息时阻塞的）
3. 同步非阻塞形式（开线程）
4. 异步非阻塞形式（效率最高）*** 

空间复用/时间复用(充分利用内存，提高代码运行效率)

硬件上内存隔离解决程序切换的不安全

分时系统：常用（每个程序执行一点时间）不一定能提高效率,只是让程序看起来在同时运行

实时系统：高进度行业，不切换

进程的创建：

1. 系统初始化
2. 一个进程在运行过程中开启了子进程（常用）
3. 用户的交互式请求，而创建的一个新进程（如用户双击暴风影音）
4. 一个批处理作业的初始化（只在大型机的批处理系统中应用）

进程结束：

1. 正常退出（自愿）
2. 出错退出（自愿）
3. 严重错误（非自愿，执行非法指令，如引用不存在的内存）
4. 被其他进程杀死

进程并发的实现(硬件中断一个正在运行的进程,把此时进程运行的所有状态保存下来)

multiprocess模块(python中的一个操作,管理进程的包)

import time
from multiprocessing import Process
def f1(n):
    time.sleep(3)
    print(i)
if __name__ == '__main__'：
    for i in range(20):
        p1 = Process(target = f1,args=(i,))  # i为传入参数或者kwargs ={'n':'i'}
        p1.start()       #多进程执行顺序操作系统决定

import time
from multiprocessing import Process
def f1():
    time.sleep(3)
    print(‘aaaa’)
def f2():
    time.sleep(3)
    print(‘bbb’)
if __name__ == ‘__main__’：
    p1 = Process(target = f1,)
    p2 = Process(target = f2,)
    p1.start()    #给操作系统发信号创建进程，输出顺序不一定
    p2.start()    #多进程，有I/O切换执行，耗时3s左右，并发代码运行效率提高了一倍
    p1.join()  #主进程等待子进程，如果没有join命令，会继续执行主进程，CPU执行代码速度快于操作系统
    p2.join()
    print(‘主进程’)

class MyProcess(Process):   #继承类创建进程对象
    def __init__(self,n):
        super().__init__()   #执行父类的init
        self.n = n
    def run(self):
        print('a and %s'%self.n)
if __name__ == '__main__':
    p1 = Myprocess('b') 
    p1.start()         #a and b

多进程可以通过for循环创建

进程的其他方法

import time
import os
from multiprocessing import Process
def f1():
   time.sleep(3)
   print('子进程的id', os.getpid())
   print('子进程的父进程id',os.getppid())
   print('aaaa')
def f2():
   time.sleep(3)
   print('bbb')

if __name__ =='__main__':
   p1 = Process(target = f1,name = 'a')
   p2 = Process(target = f2,)
   p1.start()
   p2.start()
   print(p1.name)         #a
   print('子进程',p1.pid)
   print('父进程的id',os.getpid())

from multiprocessing import Process
import time
def f1():
   time.sleep(1)
   print('子进程1')
if __name__ == '__main__':
   p = Process(target = f1,)
   p.start()
   print(p.is_alive())  #判断子进程是否还活着,是否还在运行  True
   p.terminate()   #给操作系统发送一个结束进程的信号
   time.sleep(0.5)   #操作系统结束进程需要一点时间
   print(p.is_alive())# False

 进程之间是空间隔离的,子进程变量修改,不改变主进程的

守护进程

将该进程设置为守护进程,必须写在start之前,如果主进程代码运行结束,则子进程不管运行到什么地方都直接结束

守护进程会跟着父进程的代码运行结束,就结束

import time
from multiprocessing import Process
def f1():
   time.sleep(3)
   print('xxx')

def f2():
   time.sleep(2)
   print('aaa')

if __name__ == '__main__':
   p = Process(target=f1,)
   p.daemon = True
   p.start()        #如果运行时间短于主进程,则无法打印
   p2 = Process(target=f2,)
   p2.start()         #未被守护.不影响正常运行aaa
   print('主进程结束')   #主进程结束则结束f1