并发编程-多进程

进程篇

本章目录：

什么是进程

进程与程序

进程PID与PPID

并发与并行，阻塞与非阻塞

python实现多进程

孤儿进程与僵尸进程

什么是并发编程

并发指的是多个任务同时被执行，并发编程指的是编写支持多任务并发的应用程序在。

之前的TCP通讯中，服务器在建立连接后需要一个循环来与客户端循环的收发数据，但服务器并不知道客户端什么时候会发来数据，导致没有数时服务器进入了一个等待状态，此时其他客户端也无法链接服务器，很明显这是不合理的，学习并发编程就是要找到一种方案，让一个程序中的的多个任务可以同时被处理；

什么是进程

进程指的是正在运行的程序，是一系列过程的统称，也是操作系统在调度和进行资源分配的基本单位

进程是实现并发的一种方式，在学习并发编程之前要先了解进程的基本概念以及多进程的实现原理，这就不得不提到操作系统了，因为进程这个概念来自于操作系统，没有操作系统就没有进程

多进程的实现原理 见:
https://www.cnblogs.com/yangyuanhu/p/11112763.html

进程与程序

进程是正在运行的程序，程序是程序员编写的一堆代码，也就是一堆字符，当这堆代码被系统加载到内存中并执行时，就有了进程。

例如：生活中我们会按照菜谱来做菜，那么菜谱就是程序，做菜的过程就是进程

需要注意的是：一个程序是可以产生多个进程的，就像我们可以同时运行多个QQ程序一样，会形成多个进程

测试：

import time
while True：
	time.sleep(1)

多次运行该文件，就会产生多个python.exe进程，可以通过tasklist来查看运行的程序

PID和PPID

PID

在一个操作系统中通常都会运行多个应用程序，也就是多个进程，那么如何来区分进程呢？

系统会给每一个进程分配一个进程编号即PID，如同人需要一个身份证号来区分。

验证：

tasklist 用于查看所有的进程信息

taskkill /f /pid pid 该命令可以用于结束指定进程

# 在python中可以使用os模块来获取pid
import os
print(os.getpid())

PPID

当一个进程a开启了另一个进程b时，a称为b的父进程，b称为a的子进程

在python中可以通过os模块来获取父进程的pid

# 在python中可以使用os模块来获取ppid
import os
print("self",os.getpid()) # 当前进程自己的pid
print("parent",os.getppid()) # 当前进程的父进程的pid

如果是在pycharm中运行的py文件，那pycahrm就是这个python.exe的父进程，当然你可以从cmd中来运行py文件，那此时cmd就是python.exe的父进程

并发与并行，阻塞与非阻塞

并发指的是，多个事件同时发生了

例如洗衣服和做饭，同时发生了，但本质上是两个任务在切换，给人的感觉是同时在进行，也被称为伪并行

并行指的是，多个事件同时进行着

例如一个人在写代码另一个人在写书，这两件事件是同时在进行的，要注意的是一个人是无法真正的并行执行任务的，在计算机中单核CPU也是无法真正并行的，之所以单核CPU也能同时运行qq和微信其实就是并发执行

阻塞与非阻塞指的是程序的状态

阻塞状态是因为程序遇到了IO操作，或是sleep，导致后续的代码不能被CPU执行

非阻塞与之相反，表示程序正在正常被CPU执行

补充：进程有三种状态

就绪态，运行态，和阻塞态

多道技术会在进程执行时间过长或遇到IO时自动切换其他进程，意味着IO操作与进程被剥夺CPU执行权都会造成进程无法继续执行

进程相关理论

进程的创建

但凡是硬件，都需要有操作系统去管理，只要有操作系统，就有进程的概念，就需要有创建进程的方式，一些操作系统只为一个应用程序设计，比如微波炉中的控制器，一旦启动微波炉，进程就已经存在。

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

　　1. 系统初始化（查看进程linux中用ps命令，windows中用任务管理器，前台进程负责与用户交互，后台运行的进程与用户无关，运行在后台并且只在需要时才唤醒的进程，称为守护进程，如电子邮件、web页面、新闻、打印）

　　2. 一个进程在运行过程中开启了子进程（如nginx开启多进程，os.fork,subprocess.Popen等）

　　3. 用户的交互式请求，而创建一个新进程（如用户双击暴风影音）

　　4. 一个批处理作业的初始化（只在大型机的批处理系统中应用）

　　

　　无论哪一种，新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的：

　　1. 在UNIX中该系统调用是：fork，fork会创建一个与父进程一模一样的副本，二者有相同的存储映像、同样的环境字符串和同样的打开文件（在shell解释器进程中，执行一个命令就会创建一个子进程）

　　2. 在windows中该系统调用是：CreateProcess，CreateProcess既处理进程的创建，也负责把正确的程序装入新进程。

　

　　关于创建的子进程，UNIX和windows

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

　　2.不同的是：在UNIX中，子进程的初始地址空间是父进程的一个副本，提示：子进程和父进程是可以有只读的共享内存区的。但是对于windows系统来说，会重新加载程序代码。

进程的销毁

　1. 正常退出（自愿，如用户点击交互式页面的叉号，或程序执行完毕调用发起系统调用正常退出，在linux中用exit，在windows中用ExitProcess）

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

　3. 严重错误（非自愿，执行非法指令，如引用不存在的内存，1/0等，可以捕捉异常，try...except...）

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

进程的层次结构

无论UNIX还是windows，进程只有一个父进程，不同的是：

　　1. 在UNIX中所有的进程，都是以init进程为根，组成树形结构。父子进程共同组成一个进程组，这样，当从键盘发出一个信号时，该信号被送给当前与键盘相关的进程组中的所有成员。

　　2. 在windows中，没有进程层次的概念，所有的进程都是地位相同的，唯一类似于进程层次的暗示，是在创建进程时，父进程得到一个特别的令牌（称为句柄）,该句柄可以用来控制子进程，但是父进程有权把该句柄传给其他子进程，这样就没有层次了。

python中实现多进程

在一个应用程序中可能会有多个任务需要并发执行，但是对于操作系统而言，一个进程就是一个任务，CPU会从上往下依次执行代码，当代码中遇到IO操作时，操作系统就会剥夺CPU执行权给其他应用程序，这样对于当前应用程序而言，效率就降低了，如何使得程序既能完成任务又不降低效率呢？答案就是让把当前程序中的耗时操作交給子进程来完成，如此当前应用程序可以继续执行其他任务！

python中开启子进程的两种方式

方式1：

实例化Process类

from multiprocessing import Process
import time

def task(name):
    print('%s is running' %name)
    time.sleep(3)
    print('%s is done' %name)
if __name__ == '__main__':
    # 在windows系统之上，开启子进程的操作一定要放到这下面
    # Process(target=task,kwargs={'name':'egon'})
    p=Process(target=task,args=('jack',))
    p.start() # 向操作系统发送请求，操作系统会申请内存空间，然后把父进程的数据拷贝给子进程，作为子进程的初始状态
    print('======主')

方式2：

继承Process类 并覆盖run方法

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        super(MyProcess,self).__init__()
        self.name=name

    def run(self):
        print('%s is running' %self.name)
        time.sleep(3)
        print('%s is done' %self.name)
if __name__ == '__main__':
    p=MyProcess('jack')
    p.start()
    print('主')

需要注意的是

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

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

3.start仅仅是给操作系统发送消息，而操作系统创建进程是要花费时间的，所以会有两种情况发送

​ 3.1开启进程速度慢于程序执行速度，先打印”主“ 在打印task中的消息

​ 3.2开启进程速度快于程序执行速度，先打印task中的消息，在打印”主“

进程间内存相互隔离

from multiprocessing import Process
import time
x=1000
def task():
    global x
    x=0
    print('儿子死啦',x)


if __name__ == '__main_
    print(x)
    p=Process(target=task)
    p.start()
    time.sleep(5)
    print(x)

join函数

调用start函数后的操作就由操作系统来玩了，至于何时开启进程，进程何时执行，何时结束都与应用程序无关，所以当前进程会继续往下执行，join函数就可以是父进程等待子进程结束后继续执行

案例1：

from multiprocessing import Process
import time

x=1000

def task():
    time.sleep(3)
    global x
    x=0
    print('儿子死啦',x)
if __name__ == '__main__':
    p=Process(target=task)
    p.start()

    p.join() # 让父亲在原地等
    print(x)

案例2：

from multiprocessing import Process
import time,random

x=1000

def task(n):
    print('%s is runing' %n)
    time.sleep(n)

if __name__ == '__main__':
    start_time=time.time()

    p1=Process(target=task,args=(1,))
    p2=Process(target=task,args=(2,))
    p3=Process(target=task,args=(3,))
    p1.start()
    p2.start()
    p3.start()

    p3.join() #3s
    p1.join()
    p2.join()

    print('主',(time.time() - start_time))

    start_time=time.time()
    p_l=[]
    for i in range(1,4):
        p=Process(target=task,args=(i,))
        p_l.append(p)
        p.start()
    for p in p_l:
        p.join()
    
    print('主',(time.time() - start_time))

Process对象常用属性

from multiprocessing import Process
def task(n):
    print('%s is runing' %n)
    time.sleep(n)

if __name__ == '__main__':
    start_time=time.time()
    p1=Process(target=task,args=(1,),name='任务1')
    p1.start() # 启动进程
    print(p1.pid) # 获取进程pid
    print(p1.name) # 获取进程名字
    p1.terminate() # 终止进程
    p1.join() # 提高优先级
    print(p1.is_alive()) # 获取进程的存活状态
    print('主')

孤儿进程与僵尸进程

什么是孤儿进程

孤儿进程指的是开启子进程后，父进程先于子进程终止了，那这个子进程就称之为孤儿进程

例如：qq聊天中别人发给你一个链接，点击后打开了浏览器，那qq就是浏览器的父进程，然后退出qq，此时浏览器就成了孤儿进程

孤儿进程是无害的，有其存在的必要性，在父进程结束后，其子进程会被操作系统接管。

什么是僵尸进程

僵尸进程指的是，当子进程比父进程先结束，而父进程又没有回收子进程，释放子进程占用的资源，此时子进程将成为一个僵尸进程。该情况仅在linux下出现。windows中进程间完全是独立的没有任何关联。

如果父进程先退出 ，子进程被操作系统接管，子进程退出后操作系统会回收其占用的相关资源！

僵尸进程的危害：

由于子进程的结束和父进程的运行是一个异步过程，即父进程永远无法预测子进程 到底什么时候结束. 那么会不会因为父进程太忙来不及wait子进程，或者说不知道 子进程什么时候结束，而丢失子进程结束时的状态信息呢? 不会。因为UNⅨ提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息， 就必然可以得到。这种机制就是： 在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等。但是仍然为其保留一定的信息（包括进程号the process ID，退出状态the termination status of the process，运行时间the amount of CPU time taken by the process等）。直到父进程通过wait / waitpid来取时才释放. 但这样就导致了问题，如果进程不调用wait / waitpid的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生[僵死进程]，将因为没有可用的进程号而导致系统不能产生新的进程. 此为僵尸进程的危害，应当避免。

好消息是：python已经帮我们自动处理了僵尸进程的回收工作