Python多任务编程思想（一）

1. 多任务编程：
    利用计算机的多核特点，同时执行多个任务。通过充分地利用计算机资源，来提高程序的运行效率。
    实现：
        多进程
        多线程
    ①并行 ＆＆ 并发
        并行：多个计算机核心同时处理多个任务；多个任务之间是并行关系
        并发：计算机同时处理多个任务，内核在多个任务之间不断切换，达到好像在同时处理的运行效果。此时多个任务实际为并发关系，如IO多路复用。
    ②进程 ＆＆ 程序
        进程：程序在计算机中运行一次的过程，是一个动态的过程描述；占有CPU内存等计算机资源，具有一定的生命周期
        程序：静态的可执行文件，占有磁盘，不占有计算机的运行资源；磁盘不属于计算机资源
        备注：同一个程序的不同执行过程，分配的计算机资源不同，属于不同的进程

２. 进程的创建流程：
    ①用户空间运行一个程序，发起进程创建
    ②操作系统接受用户请求，开启进程创建
    ③操作系统分配系统资源，确认进程状态
    ④将创建好的进程提供给应用层使用

３. 进程相关概念
    ①CPU时间片
        如果一个进程占有计算机核心，我们称为该进程在CPU的时间片上。多个任务实际对CPU会进行争夺，一般由操作系统分配CPU时间片
    ②进程控制块
        PCB(Processing Control Block)
        在操作系统中，进程创建后会自动产生一个空间存放进程信息，称为进程控制块。进程信息包含进程PID、进程占有的内存位置、创建时间、用户、状态等
    ③进程PID
        进程在操作系统中的唯一编号，是一个大于０的整数，由系统自动分配。
④进程的特征
        进程是操作系统分配'计算机资源'的最小单位。
        每个进程都有自己单独的虚拟内存空间,进程间的执行相互独立，互不影响。
    ⑤ps -aux 查看进程信息
        D    等待态    不可中断等待
        S    等待态    可中断等待
        T    等待态    暂停状态
        R    运行态    就绪态，运行态
        Z    僵尸态    进程已经结束，但仍存在一些问题解决

        +    前台进程
        <    高优先级
        N    低优先级
        l    有进程链接
        s    会话组组长
    ⑥进程的状态：
        三态：
            1)就绪：进程具备执行条件，等待系统分配CPU
            2)执行：进程占有CPU时间片，处于运行状态
            3)等待：进程暂时不具备运行条件，需要阻塞等待
        五态（增加新建态和终止态）：
            1)新建：创建一个新的进程，获取资源的过程
            2)终止：进程结束，释放资源的过程
    ⑦进程优先级：
        优先级决定了一个进程的执行权限和占有资源的优先程度
        top : 动态地查看进程优先级 # 取值范围：-20 --- 19, 其中-20优先级最高
        nice : 指定优先级运行程序    
           sudo nice -9 ./while.py  #指定以-9优先级来运行程序
    ⑧父子进程:
        除了初始化进程，每个进程都有一个父进程，也可能有０个或者多个子进程。形成父子进程关系。
        pstree ：查看进程树
        ps -ajx : 查看父进程PID

4. 进程的相关函数：
    ①os.getpid()
        功能：获取当前进程的pid号
        返回值：返回PID号
    ②os.getppid()
        功能:获取父进程的pid号
        返回值:返回PID号
    ③os._exit(status)
        功能：退出进程
        返回值：使用整数标识进程的退出状态,并通过人为赋予相应的含义
    ④sys.exit([status])
        功能：退出状态
        返回值：默认为０，如果是整数，则表示退出状态;如果是字符串，则表示在退出时打印内容。
        备注：sys.exit()可以通过捕获SystemExit异常阻止退出

5. 孤儿进程:
    父进程先于子进程退出，此时子进程就会成为孤儿进程。
    孤儿进程会被系统指定的进程收养，即系统进程会成为该孤儿进程新的父进程,处理孤儿进程的退出状态；
    孤儿进程一定不会成为僵尸进程。

６. 僵尸进程:
    子进程先于父进程退出，并且父进程没有处理子进程退出状态，此时子进程成为僵尸进程；
    僵尸进程已经结束，但是会滞留部分PCB信息在内存，大量的僵尸会消耗系统资源，应该尽量避免僵尸进程的产生。
    
7. 创建进程的方法（一）

    os.fork()函数，os模块是Python中和操作系统及平台相关的模块。具体过程请见示意代码：

'''pid = os.fork()创建子进程
①os.fork()创建子进程失败时返回负数
②os.fork()创建子进程成功时返回一个非负数：
    在子进程中，返回值pid=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("在子进程中将a的值设置为1000")
else:
    print(pid)
    time.sleep(4)
    #空间独立，互不影响
    print('父进程：a =',a)

print("程序执行完毕！")
print(time.ctime())

8.如何避免僵尸进程的产生：
    ①父进程先退出
            １）父进程创建子进程等待子进程退出
            ２）子进程创建二级子进程，然后立马退出
            ３）二级子进程成为孤儿，处理具体事宜
     示意代码：

''' 创建二级子进程
wait处理一级子进程，二级子进程为孤儿进程；
子进程只负责创建二级子进程，然后立即退出，不会造成wait的阻塞
'''
import os
from time import sleep,ctime

def func1():
    sleep(3)
    print('First issue')

def func2():
    sleep(4)
    print('Second issue')

pid = os.fork()

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

   ②父进程处理子进程的状态
        pid,status = os.wait()
            功能：在父进程中阻塞等待处理子进程的退出
            返回值：pid 退出的子进程PID号
                 status 子进程的退出状态(默认为０)

            示意代码：

import os
import sys
from time import sleep

pid = os.fork()

if pid < 0:
    print("Create process failed!")
elif pid == 0:
    sleep(3)
    print("子进程PID:",os.getpid())
    sys.exit(2)
else:
    # 阻塞等待子进程退出
    pid,status = os.wait()
    # 退出状态2 * 256,便于系统的识别
    print(pid,status)
    # 打印sys.exit(2)设置的退出状态
    print(os.WEXITSTATUS(status))
    while True:
        pass

        pid,status = os.waitpid(pid,option)
            功能,返回值:同wait
            参数:
                pid         -1            表示任意子进程退出
                             >0            指定PID号的子进程退出
                option    0             表示阻塞等待
                       WNOHANG   表示非阻塞
            waitpid(-1,0) 等价于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("子进程PID:",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):
            break
        print("Do something others!")

    ③常用方法：signal.signal(signal.SIGCHLD,signal.SIG_IGN)

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

9. 创建进程的方法（二）
    使用multiprocessing模块
        ①需要将要做的事情封装为函数；
        ②使用multiprocessing中提供的Process类创建进程对象；
        ③通过进程对象和process初始化函数，对进程进行设定，并且绑定要执行的事件
        ④启动进程，会自动执行相关联函数
        ⑤事件完成后回收进程
    创建进程对象：
        Process(name,target,*args,**kwargs)
        功能：创建进程对象
        参数：
            name 给创建的进程对象起一个名字 default:Process-n
            target 绑定事件函数
            args     给'target函数'按照位置传参
            kwargs 给'target函数'按照关键字传参
    P.start()
        启动进程，此时进程被创建。并自动执行进程函数
    P.join([timeout])
        功能：阻塞等待回收响应的进程
        参数：超时时间

    示意代码：

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

a = 1

def func():
    '''修改子进程空间的内容，不会对父进程产生影响'''
    global a
    a = 100
    print('在子进程中，a =',a)
    print('子进程PID:',os.getpid())
    print('父进程PID:',os.getppid())

# 创建进程对象
p = mp.Process(target=func)

# 启动进程
p.start()

# 延迟5s,使子进程修改了变量a绑定的值
time.sleep(5)
print('这里是父进程:a = ',a)
# 在父进程中，可以通过p.pid获取创建进程的PID号
print('子进程PID:',p.pid)
print('父进程PID:',os.getpid())

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

# 运行结果
# 在子进程中，a = 100
# 子进程PID: 4670
# 父进程PID: 4669
# 这里是父进程:a =  1
# 子进程PID: 4670
# 父进程PID: 4669

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