多进程之理论与开启进程的方式

进程和程序的区别

程序

　　程序就是一堆计算机可以识别的文件，程序在没有被运行时就是躺在硬盘上的一堆二进制

　　运行程序时，要从硬盘读取数据到内存中，CPU再从内存中读取指令并执行

进程

　　一旦程序运行就会产生进程

　　一个程序可以多次执行，产生多个进程，但是进程之间时相互独立的

　　当我们右键运行一个py文件时，其实启动的时python解释器，你的py文件其实是当作参数传给了解释器

阻塞 非阻塞 并行 并发 ******

1、阻塞：程序运行时遇到IO操作时就进入了阻塞状态

　　　　本地IO：input　　print　　sleep　　read　　write

　　　　网络IO：recv　　send

2、非阻塞：程序正常运行中，没有任何IO操作，就处于非阻塞状态

##   阻塞 非阻塞 说的是程序的运行状态

3、并发：多个任务看起来同时在处理，本质上时切换执行，只是速度非常快而已

4、并行：多个任务真正的同时执行，必须具备多核CPU，才可以并行

## 并发  并行  说的是任务的处理方式

进程的三种状态以及之间的切换

1、运行态：程序正常执行

2、阻塞态：遇到io操作进入阻塞状态

3、就绪态：io执行完毕进入就绪状态，并向cpu发出信息(等待cpu过来执行)

提高进程效率的方法

根本方法就是让程序尽可能处于运行的状态

减少I/O操作  或者  尽可能多的占用CPU时间

之前学的缓冲区就是用于减少I/O操作，一次多拿点数据，减少拿的次数

进程的创建与销毁

进程的创建

但凡时硬件，就需要有操作系统取管理，只要有操作系统，就有进程的概念，就需要有创建进程的方式，

一些操作系统只为一个应用程序设计，比如自动洗衣机，一旦启动，进程就已经存在

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

　　--1、系统初始化（就是只有在需要的时候才启动进程，例如web页面滑到对应的界面才唤醒的进程，也称为守护进程）

　　--2、一个进程在运行过程中开启了子进程（例如我们在pycharm中运行py文件开启了python解释器的进程）

　　--3、用户交互式请求，创建新的进程（例如在GUI界面双击某个应用程序）

　　--4、一个批处理作业的初始化(只有在大型机的批处理系统中应用)，现在基本没有了，了解即可　　

创建子进程unix与windows的比较

1、相同点：进程创建后，父进程和子进程有各自不同的地址空间(多道技术要求物理层面实现进程之间内存的隔离)，任何一个进程的在其地址空间中的修改都不会影响到另外一个进程

2、不同点：在unix中，子进程的初始地址空间时父进程的一个副本，但对于windows来说，需要重新加载程序代码，所以需要把创建子进程的一些代码放到自执行的判断中

进程的销毁

1、正常退出（自愿，如用户点击交互式页面的×，或者程序执行完毕调用发起系统调用正常退出）

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

3、严重错误（非自愿，执行非法操作时，如引用不存在的内存，可以捕捉异常）

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

python中实现多进程

在一个应用程序中可能会有多个任务需要并发执行，但是对于操作系统而言，一个进程就是一个任务，

当程序执行过程中遇到I/O操作时，操作系统就会把cpu调给其他应用程序，这对于当前应用程序来说效率就降低了

如何让程序既能完成任务又不降低效率，就需要把耗时的操作交给子进程来完成

开启子进程的两种方式

在python中，想要开启子进程，需要用到multiprocessing模块中的Process类

1、直接实例化Process类

from multiprocessing import Process
import time
def task(name):     # 创建函数，里面是需要子进程执行的代码块
    print("子进程  run")
    time.sleep(3)   # 模拟任务需要耗时
    print(name)
    print("子进程  over")

if __name__ == '__main__': # 创建子进程的代码必须放在这个判断下面，因为windows会导入一下这文件
    # target指定的子进程要执行的任务 args里传入的是子进程需要的参数,需要几个传几个
    p = Process(target=task,args=("xxx","sad ")) 
    print("父进程  run")
    p.start()
    time.sleep(2)
    print("父进程  over")
# 运行结果表明，子进程和当前进程看起来是同时执行（并发）

2、继承Process类并且覆盖run方法

from multiprocessing import Process
import time
class MyProcess(Process):   # 继承Process类

    def __init__(self,name): # 想要往子进程里传入参数，必须在__init__函数中加入属性
        super().__init__()
        self.name = name

    def run(self):  # 覆盖Process的run方法，里面放入子进程要执行的代码块
        print("子进程  run")
        time.sleep(1)
        print(self.name)
        time.sleep(1)
        print("子进程  over")

if __name__ == '__main__':
    p = MyProcess("rose")
    print("父进程  run")
    p.start()
    time.sleep(1)
    print("父进程  over")

需要注意的是：

　　1、在windows下 开启子进程函数必须放到__main__下面，因为windows在开启子进程时会重新加载所有的代码造成递归创建进程

　　2、第二种方式中，必须将要执行的代码放到run方法中，子进程只会执行run方法，其他一概不管

进程之间的内存空间是隔离的

from multiprocessing import Process
a = 1000
def task():
    global a
    a = 10
    print(a)

if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    print(a)
    # 1000
    # 10    运行结果表明进程间内存时相互隔离的

join方法

from multiprocessing import Process
import time
def task():
    print("子进程  run")
    time.sleep(2)
    print("子进程  over")

if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()
    print("我是父进程")

    # 子进程  run
    # 子进程  over
    # 我是父进程         结果表明join函数是让父进程等待该子进程运行完之后才继续往下执行

既然join方法是让父进程等待子进程运行结束才执行代码，那么是不是又变成串行了？？？

　　如果你只是开启一个子进程的话，那这样确实变成串行（那你也没必要开子进程了）

　　但如果开启了多个子进程的话，join函数只会让父进程等该子进程运行结束才执行，但是并不会限制其他子进程的执行

from multiprocessing import Process
import time
def task():
    print("子进程  run")
    time.sleep(2)
    print("子进程  over")

if __name__ == '__main__':
    p1 = Process(target=task)
    p2 = Process(target=task)
    p3 = Process(target=task)
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    print("我是父进程")
# 结果表明 2 秒之后 3个子进程基本同时(并行)执行完毕，然后父进程继续执行代码

process对象的常用方法

p = Process(target=task)
p.start()  # 向操作系统发送开启进程的指令，需要一定时间
p.join()  # 等待子进程结束，父进程再执行往后的代码
p.terminate()  # 终止进程 也是向操作系统发送指令，需要延迟
print(p.name) # 进程的名称
print(p.is_alive()) # 查看进程是否存活
print(p.pid)  # 查看进程的pid
# 需要注意的是：process对象是惰性的，如果不发送start指令，p对象相当于没有创建

僵尸进程与孤儿进程

孤儿进程

　　指的是，父进程先结束，而子进程还在运行着，由操作系统接管

　　孤儿进程是无害的，并且是由存在的必要性的

　　例如：qq开启的浏览器，qq退出了，浏览器应该继续运行，因为它的任务可能还没有运行结束

僵尸进程

　　僵尸进程指的是，子进程已经结束了，但是操作系统会保存一些进程信息，如PID，运行时间等（证明这个进程开启过），此时，这个进程就成为僵尸进程，占用系统资源

　　僵尸进程如果太多将会占用大量的资源，造成系统无法开启新的进程

　　在Linux中，父进程需要调用wait/waitpid来获取子进程的残留信息，并清理它

　　python会自动回收僵尸进程