一. 多任务编程
多任务编程指利用计算机的多核特点，同时执行多个任务。通过充分地利用计算机资源，来提高程序的运行效率。如多线程和多进程编程。在开始学习多任务编程前，区分如下几个概念非常重要
1.1 并行和并发
当多个计算机核心同时处理多个任务时，多个任务之间是并行关系，因此并行数量取决于计算机核心数。计算机同时处理多个任务，内核在多个任务之间不断切换，达到好像在同时处理的运行效果，此时多个任务实际为并发关系，如IO多路复用。
举一个生活中的列子：当只有一个咖啡机时，两队人排队交替使用一个咖啡机，这是并发；而当我们有2台咖啡机时，两队人员就能同时使用各自的咖啡机，互补干扰。那么回到计算机中：
- 并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。
- 并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。
1.2 进程和程序
进程：程序在计算机中运行一次的过程，是一个动态的过程描述，占有CPU内存等计算机资源，具有一定的生命周期。同一个程序的不同执行过程，分配的计算机资源不同，属于不同的进程。
一个进程的创建流程如下：
- 用户空间运行一个程序，发起进程创建
- 操作系统接受用户请求，开启进程创建
- 操作系统分配系统资源，确认进程状态
- 将创建好的进程提供给应用层使用
程序：静态的可执行文件，占有磁盘，不占有计算机的运行资源；磁盘不属于计算机资源。
二. 进程
2.1 相关概念
CPU时间片：如果一个进程占有计算机核心，我们称为该进程在CPU的时间片上。多个任务实际对CPU会进行争夺，一般由操作系统分配CPU时间片。
进程控制块PCB(Processing Control Block)：在操作系统中，进程创建后会自动产生一个空间存放进程信息，称为进程控制块。进程信息包含进程PID、进程占有的内存位置、创建时间、用户、状态等。
进程PID：进程在操作系统中的唯一编号，是一个大于０的整数，由系统自动分配。
进程的特征：进程是操作系统分配“计算机资源”的最小单位。每个进程都有自己单独的虚拟内存空间，进程间的执行相互独立，互不影响。
ps -aux 查看进程信息
| STAT | 描述 |
|---|---|
| D | 等待态，且为不可中断等待 |
| S | 等待态，为可中断等待 |
| T | 等待态，为暂停状态 |
| R | 就绪态，运行态 |
| Z | 僵尸态 ，进程已经结束，但仍存在一些问题解决 |
| + | 前台进程 |
| < | 高优先级 |
| N | 低优先级 |
| I | 有进程链接 |
| s | 会话组组长 |
进程的状态
三态：
- 就绪：进程具备执行条件，等待系统分配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函数
- os.fork()创建子进程失败时返回负数，成功时返回一个非负数；
- 在子进程中，返回值为0；在父进程中，返回值为子进程的PID；
- 子进程从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 如何避免僵尸进程的产生
当子进程先于父进程退出，如果父进程没有处理子进程退出状态，此时子进程成为僵尸进程。因为为了避免产生僵尸，首先想到的即让“父进程先于子进程退出”，具体实现如下：
- 父进程创建子进程等待子进程退出；
- 子进程创建二级子进程，然后立马退出；
- 二级子进程成为孤儿，处理具体事宜；
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则可以指定阻塞和非阻塞。具体如下：
-
pid,status = os.waitpid(pid,option)处理子进程的退出 -
pid-1：任意子进程退出；>0：指定PID号的子进程退出； -
option0：阻塞等待；WNOHANG：非阻塞 -
pid, status = waitpid(-1,0)等价于pid, status = wait()
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在主进程中处理子进程的退出状态外，更常用的一种方式是利用系统内核，异步地处理子进程退出问题。实现过程大致如下：
- 在多任务程序初始化时，（注意，需要导入signal标准库模块）声明signal.signal(signal.SIGCHLD, signal.SIG_IGN)；
- 内核发现子进程退出时，会给主进程发送一个SIGCHLD信号，signal的第二个参数是主进程对子进程的处理方式；
- SIG_IGN即主进程忽略子进程的退出，并交由系统处理回收子进程的退出。（此处不再详细举例，后续介绍进程间通信方式时，再对信号做详细介绍）
3.2 使用multiprocessing模块
multiprocessing模块中，需要将要做的事情封装为函数，使用multiprocessing中提供的Process类，在实例化时传入target函数，创建进程对象。p.start启动进程后，会自动执行相关联函数，并在事件完成后回收进程。此过程用到的主要类、方法如下：
| 类/方法 | 参数 |
|---|---|
Process(name,target,*args,**kwargs) |
创建进程对象： name：给创建的进程对象起一个名字，default:Process-n；target：绑定的事件函数；args：给“target”函数'按照位置传参；kwargs：给“target”函数'按照关键字传参； |
P.start() |
启动进程，并自动执行进程函数。 |
P.join([timeout]) |
阻塞等待回收响应的进程。timeout可选参数：超时时间 |
'''通常使用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创建进程，父进程只用作进程的创建和回收，不做其他工作。