Python实现多进程（一）

一. 多任务编程

       多任务编程指利用计算机的多核特点，同时执行多个任务。通过充分地利用计算机资源，来提高程序的运行效率。如多线程和多进程编程。在开始学习多任务编程前，区分如下几个概念非常重要

1.1 并行和并发

​​​​       当多个计算机核心同时处理多个任务时，多个任务之间是并行关系，因此并行数量取决于计算机核心数。计算机同时处理多个任务，内核在多个任务之间不断切换，达到好像在同时处理的运行效果，此时多个任务实际为并发关系，如IO多路复用。

       举一个生活中的列子：当只有一个咖啡机时，两队人排队交替使用一个咖啡机，这是并发；而当我们有2台咖啡机时，两队人员就能同时使用各自的咖啡机，互补干扰。那么回到计算机中：

• 并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。
• 并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

1.2 进程和程序

• 进程：程序在计算机中运行一次的过程，是一个动态的过程描述，占有CPU内存等计算机资源，具有一定的生命周期。同一个程序的不同执行过程，分配的计算机资源不同，属于不同的进程。一个进程的创建流程如下：
  • 用户空间运行一个程序，发起进程创建
  • 操作系统接受用户请求，开启进程创建
  • 操作系统分配系统资源，确认进程状态
  • 将创建好的进程提供给应用层使用
• 程序：静态的可执行文件，占有磁盘，不占有计算机的运行资源；磁盘不属于计算机资源。

二. 进程

2.1 相关概念

• CPU时间片：如果一个进程占有计算机核心，我们称为该进程在CPU的时间片上。多个任务实际对CPU会进行争夺，一般由操作系统分配CPU时间片。
• 进程控制块PCB(Processing Control Block)：在操作系统中，进程创建后会自动产生一个空间存放进程信息，称为进程控制块。进程信息包含进程PID、进程占有的内存位置、创建时间、用户、状态等。
• 进程PID：进程在操作系统中的唯一编号，是一个大于０的整数，由系统自动分配。
• 进程的特征：进程是操作系统分配“计算机资源”的最小单位。每个进程都有自己单独的虚拟内存空间，进程间的执行相互独立，互不影响。
• ps -aux 查看进程信息

• 进程的状态
  • 三态：
    • 就绪：进程具备执行条件，等待系统分配CPU
    • 执行：进程占有CPU时间片，处于运行状态
    • 等待：进程暂时不具备运行条件，需要阻塞等待
  • 五态（增加新建态和终止态）：
    • 新建：创建一个新的进程，获取资源的过程
    • 终止：进程结束，释放资源的过程
• 进程优先级：优先级决定了一个进程的执行权限和占有资源的优先程度
  • top命令 : 动态地查看进程优先级，其中NI的取值范围为-20~19，其中-20优先级最高
  • nice : 运行程序时指定优先级；

sudo nice -9 ./while.py  # 指定以-9优先级来运行程序

• 父子进程：除了初始化进程，每个进程都有一个父进程，也可能有０个或者多个子进程。
  • pstree：查看进程树
  • ps -ajx：查看父进程PID
• 进程的相关函数
  • os.getpid()：获取当前进程的PID
  • os.getppid()：获取父进程的PID
  • os._exit(status)：退出进程，使用status整数标识进程的退出状态，并通过人为赋予相应的含义
  • sys.exit([status])：默认为０，如果是整数，则表示退出状态；如果是字符串，则表示在退出时打印内容
• 孤儿进程：父进程先于子进程退出，此时子进程就会成为孤儿进程。孤儿进程会被系统指定的进程收养，即系统进程会成为该孤儿进程新的父进程，处理孤儿进程的退出状态。因此孤儿进程一定不会成为僵尸进程。
• 僵尸进程：子进程先于父进程退出，并且父进程没有处理子进程退出状态，此时子进程成为僵尸进程。僵尸进程已经结束，但是会滞留部分PCB信息在内存，大量的僵尸会消耗系统资源，应该尽量避免僵尸进程的产生。

三. 进程的创建

3.1 使用os.fork函数

1. os.fork()创建子进程失败时返回负数，成功时返回一个非负数；
2. 在子进程中，返回值为0；在父进程中，返回值为子进程的PID；
3. 子进程从pid = os.fork()语句之后开始执行，但子进程会复制父进程的全部代码段。

import os
import time

a = 1
print(time.ctime(), '程序开始执行:')

pid = os.fork()  # 创建子进程
if pid < 0:
    print('子进程创建失败!')
elif pid == 0:
    # 子进程
    time.sleep(2)
    print('子进程:a=', a)
    a = 1000
    print('在子进程中将ａ的值设为1000')
else:
    print('子进程PID:', pid)
    time.sleep(4)
    print('父进程:a=',a)  # 空间独立，互不影响

print(time.ctime(), '程序执行完毕!')

运行结果：

3.2 如何避免僵尸进程的产生

       当子进程先于父进程退出，如果父进程没有处理子进程退出状态，此时子进程成为僵尸进程。因为为了避免产生僵尸，首先想到的即让“父进程先于子进程退出”，具体实现如下：

1. 父进程创建子进程等待子进程退出；
2. 子进程创建二级子进程，然后立马退出；
3. 二级子进程成为孤儿，处理具体事宜；

import os
from time import sleep, ctime

def func1():
    sleep(3)
    print(ctime(), 'fun1()')

def func2():
    sleep(4)
    print(ctime(), 'fun2()')

pid = os.fork()

if pid < 0:
    print('create process failed!')
elif pid == 0:
    # 创建二级子进程
    pid0 = os.fork()
    if pid0 < 0:
        print('create 2th process failed!')
    elif pid0 == 0:
        func2()
        print(ctime(), '二级子进程退出!')
    else:
        # 一级子进程在创建二级子进程后立刻退出，不会造成父进程的阻塞
        print(ctime(), '一级子进程退出')
        os._exit(0)
else:
    print(ctime(), '父进程阻塞等待回收一级子进程')
    os.wait()
    func1()
    print(ctime(), '父进程退出')

运行结果：

       避免僵尸的第二种方法即在父进程中阻塞等待处理子进程的退出，使用我们上例中用到的os.wait即可。os.wait()返回值为子进程PID以及子进程的退出状态（默认为0）。

import os
import sys
from time import sleep, ctime

pid = os.fork()

if pid < 0:
    print("Create process failed!")
elif pid == 0:
    sleep(3)
    print(ctime(), "子进程{}即将退出".format(os.getpid()))
    sys.exit(2)
else:
    print(ctime(), '父进程阻塞等待子进程{}的退出'.format(pid))
    # 阻塞等待子进程退出
    pid,status = os.wait()
    print(ctime(), '父进程已处理子进程{}的退出'.format(pid))
    # 退出状态2 * 256,便于系统的识别
    print(pid,status)
    # 打印sys.exit(2)设置的退出状态
    print(os.WEXITSTATUS(status))

运行结果：

       和os.wait方法类似，os模块还提供了一个os.waitpid(pid,option)方法，pid可以指定处理的子进程PID，option则可以指定阻塞和非阻塞。具体如下：

import os
import sys
from time import sleep

pid = os.fork()

if pid < 0:
    print("Create process failed!")
elif pid == 0:
    sleep(3)
    print("子进程{}即将退出".format(os.getpid()))
    sys.exit(2)
else:
    # 等待子进程退出
    while True:
        sleep(1)
        #-1表示任意子进程　os.WNOHANG表示非阻塞
        pid,status = os.waitpid(-1,os.WNOHANG) 
        #status即子进程的退出状态sys.exit(2)　* 256
        print(pid,status)
        if os.WEXITSTATUS(status):
            print("主进程已处理{}进程的退出".format(pid))
            break
        print("Do something others!")

运行结果：

       除了使用上述的os.wait / os.waitpid在主进程中处理子进程的退出状态外，更常用的一种方式是利用系统内核，异步地处理子进程退出问题。实现过程大致如下：

1. 在多任务程序初始化时，（注意，需要导入signal标准库模块）声明signal.signal(signal.SIGCHLD, signal.SIG_IGN)；
2. 内核发现子进程退出时，会给主进程发送一个SIGCHLD信号，signal的第二个参数是主进程对子进程的处理方式；
3. SIG_IGN即主进程忽略子进程的退出，并交由系统处理回收子进程的退出。（此处不再详细举例，后续介绍进程间通信方式时，再对信号做详细介绍）

3.2 使用multiprocessing模块
       multiprocessing模块中，需要将要做的事情封装为函数，使用multiprocessing中提供的Process类，在实例化时传入target函数，创建进程对象。p.start启动进程后，会自动执行相关联函数，并在事件完成后回收进程。此过程用到的主要类、方法如下：

'''通常使用multiprocessing创建进程，父进程只用作进程的创建和回收，不做其他工作。'''
import os, time
import multiprocessing as mp

a = 1

def func():
    '''修改子进程空间的内容，不会对父进程产生影响'''
    global a
    a = 100
    print('在子进程中a =',a)
    print('子进程{}已完成func的执行，即将返回主进程{}'.format(os.getpid(), os.getppid()))

p = mp.Process(target=func)  # 创建进程对象
p.start()  # 启动进程
print('在父进程{}中创建了子进程{}'.format(os.getpid(), p.pid))
time.sleep(5)  # 延迟5s,使子进程修改了变量a绑定的值
print('父进程中:a = ',a)

p.join()  # 回收子进程,有效防止了僵尸进程的产生

运行结果：

multiprocessing创建进程总结如下：

• multiprocessing创建进程是原来进程的子进程，创建后父子进程各自执行互不影响
• 子进程同样是复制父进程的空间，子进程对内容的修改，不会影响父进程空间
• join回收子进程，会有效阻止僵尸进程产生
• 进程对象的属性：
  • p.name：进程名称，默认为Process-1，可自定义名称；
  • p.pid：创建进程的PID
  • p.daemon：默认值为False，父进程退出，不会影响子进程的运行；设置为True时，父进程退出，子进程也将退出；daemon 的设置必须在start前。如果设置daemon为True，则不再使用join，在子进程退出前，会自动做处理；
  • p.is_alive() 判断进程生命周期状态，返回True/False
• 通常使用multiprocessing创建进程，父进程只用作进程的创建和回收，不做其他工作。