python之并发编程详解

一、多任务编程
(1). 简述
多任务编程包括多进程、多线程等编程方式，可以充分的利用计算机CPU的多核资源同时处理多个应用程序任务，以此提高程序的运行效率。

二、 多任务编程之进程（process）
(1). 定义
进程指的是程序在计算机中的一次运行。程序是一个可执行的文件，是静态的占有磁盘，而进程是一个动态的过程描述，占有计算机运行资源，有一定的生命周期。

(2). 系统中如何产生一个进程？
1.用户空间通过调用程序接口或者命令发起请求；
2.操作系统接收用户请求，开始创建进程；
3.操作系统调配计算机资源，确定进程状态等；
4.操作系统将创建的进程提供给用户使用；

图2.2.1 linux

(3). 进程基本概念
1.cpu时间片
如果一个进程占有cpu内核，则称这个进程在cpu时间片上。
2.PCB(进程控制块，process control block)
在内存中开辟的一块空间，用于存放进程的基本信息，也用于系统查找识别进程。
3.进程ID（PID，process ID）
系统为每个进程分配一个大于0的整数，作为进程ID，每个进程ID不重复。

Linux查看进程ID ： ps -aux

4.父子进程（一对多）
系统中每一个进程(除了系统初始化进程)都有唯一的父进程，每个父进程可以有0个或多个子进程。父子进程关系便于进程管理。

查看进程树： pstree

5.进程状态

(1).进程的三种常用三态：  
		就绪态 ： 进程具备执行条件，等待分配cpu资源；
		运行态 ： 进程占有cpu时间片，正在运行；
		等待态 ： 进程暂时停止运行，让出cpu；
(2).进程的五种状态 (即在三态基础上增加新建和终止)：
		新建态 ： 创建一个进程，获取资源的过程；
		终止态 ： 进程结束，释放资源的过程；

图2.5.1 process状态转换

 状态查看命令 ： ps -aux  --> STAT列项
 S：等待态
 R：执行态
 Z：僵尸
 +：前台进程
 l：有多线程的

6.进程的运行特征

(1).多进程可以更充分使用计算机多核资源；
(2).进程之间的运行互不影响，各自独立；
(3).每个进程拥有独立的空间，各自使用自己空间资源；

7.面试要求

(1).什么是进程，进程和程序有什么区别；
(2).进程有哪些状态，状态之间如何转化；

三、基于fork的多进程编程

(1). fork使用
1.pid = os.fork()

(1).功能： 创建新的进程；
(2).返回值：整数，如果创建进程失败返回一个负数，如果成功则在原有进程中返回新进程的PID，在新进程中返回0；

2.fork创建进程代码演示

# -*- encoding: utf-8 -*-
"""
@File    : fork.py
@Author  : qiuyucheng
@Software: PyCharm
"""
import os
from time import sleep

# 创建子进程
pid = os.fork() #返回进程ID
if pid < 0:
    print("Create process failed")
elif pid == 0:
    # 子进程执行部分
    sleep(3)
    print("The new process")
else:
    # 父进程执行部分
    sleep(2)
    print("The old process")
print("Fork test over") #　父子进程都执行

运行结果：
	The old process
	Fork test over

3.fork创建进程代码演示2

import os
from time import sleep

print("============================")
a = 1

pid = os.fork()

if pid < 0:
    print("Error")
elif pid == 0:
    print("Child process")
    print("a = ",a)
    a = 10000
else:
    sleep(1)
    print("Parent process")
    print('a:',a)
print("all a = ",a)

运行结果：
	============================
	Child process
	a =  1
	all a =  10000
	Parent process
	a: 1
	all a =  1

4.fork使用注意事项

(1).子进程会复制父进程全部内存空间，从fork下一句开始执行。
(2).父子进程各自独立运行，运行顺序不一定。
(3).利用父子进程fork返回值的区别，配合if结构让父子进程执行不同的内容几乎是固定搭配。
(4).父子进程有各自特有特征比如PID PCB 命令集等。
(5).父进程fork之前开辟的空间子进程同样拥有，父子进程对各自空间的操作不会相互影响。

四、进程相关函数

import os
(1).os.getpid()
功能： 获取一个进程的PID值
返回值： 返回当前进程的PID 

(2).os.getppid()
功能： 获取父进程的PID号
返回值： 返回父进程PID

(3).os._exit(status)
功能: 结束一个进程
参数：进程的终止状态

sys.exit([status])
功能：退出进程
参数：整数 表示退出状态
	 字符串 表示退出时打印内容

五、孤儿进程与僵尸进程
(1). 孤儿进程
1.简述
当父进程先于子进程退出，此时子进程成为孤儿进程。

2.特点
孤儿进程会被系统进程收养，此时系统进程就会成为孤儿进程新的父进程，孤儿进程退出该进程会自动处理。

(2).僵尸进程
1.简述
子进程先于父进程退出，父进程又没有处理子进程的退出状态，此时子进程就会称为僵尸进程。

2.特点
僵尸进程虽然结束，但是会存留部分PCB在内存中，大量的僵尸进程会浪费系统的内存资源。

3.如何避免僵尸进程产生?

"""
使用wait函数处理子进程退出,
wait.py  处理僵尸进程方法

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

import os
from time import sleep

pid = os.fork()
if pid < 0:
    print("Error")
elif pid == 0:
    print("Child process:",os.getpid())
    sleep(2)
    os._exit(3) # 进程退出
else:
    pid,status = os.wait() # 阻塞等待回收子进程
    print("pid:",pid)
    print("status:",os.WEXITSTATUS(status))
    while True: # 让父进程不退出
        pass

运行结果：
	Child process: 20716
	pid: 20716
	status: 3

4.创建二级子进程处理僵尸

(1).父进程创建子进程，等待回收子进程
(2).子进程创建二级子进程然后退出
(3).二级子进程称为孤儿，和原来父进程一同执行事件

5.通过信号处理子进程退出

'''
原理： 子进程退出时会发送信号给父进程，如果父进程忽略子进程信号，
则系统就会自动处理子进程退出。
方法： 使用signal模块在父进程创建子进程前写如下语句 ：
import signal
signal.signal(signal.SIGCHLD,signal.SIG_IGN)
特点 ： 非阻塞，不会影响父进程运行，可以处理所有子进程退出。
'''
# signal  信号方法处理僵尸进程

import os
import signal

# 信号处理僵尸
signal.signal(signal.SIGCHLD,signal.SIG_IGN)

# 创建子进程
pid = os.fork()
if pid < 0:
    print("Create process failed")
elif pid == 0:
    # 子进程执行部分
    print("Child process:",os.getpid())
else:
    # 父进程执行部分
    print("Process process")
    while True:
        pass

运行结果：
	Process process
	Child process: 20951

六、multiprocessing 模块创建进程

(1). 进程创建方法

"""
multiprocessing模块创建进程
1. 创建进程任务函数
2. 创建执行该任务的进程
3. 进程启动
4. 进程回收
"""

import multiprocessing as mp
from time import sleep

a = 1

# 进程任务函数fun
def fun():
    print("执行开始...")
    sleep(3)
    global a
    print("a:",a)
    a = 10000
    print("执行结束...")

# 创建执行任务fun的子进程
p = mp.Process(target = fun)
p.start() # 启动进程

sleep(2)
print("进程执行过程中")

p.join() # 进程回收

print("======================="