Python multiprocess模块

Posted 2021-01-14 咕噜噜~

multiprocess模块
一. Process模块介绍
　　1. 直接使用Process模块创建进程
　　　　(1)主进程和子进程
　　　　(2)if __name__ == "main"语句
　　2. Process模块参数介绍
　　　　函数传参的两种方式
　　3. Process模块方法介绍
　　　　(1)join方法的使用
　　　　(2)for循环开启多个进程
　　4. Process模块属性介绍
　　5. 在windows中必须把Process()放到if __name__ == "main"语句下
二. Process类的使用
　　1. 继承的形式创建进程
　　2. 进程的内存空间是隔离的
　　3. Process对象的其他方法或属性
　　　　terminate, is_alive, 显示进程名和id
　　4. 子进程中不能有input
　　5. 僵尸进程和孤儿进程
三. 守护进程

 

 

multiprocess模块

仔细说来，multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多，为了方便大家归类记忆，我将这部分大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。重点强调：进程没有任何共享状态，进程修改的数据，改动仅限于该进程内，但是通过一些特殊的方法，可以实现进程之间数据的共享。

 

一. Process模块介绍

1. 直接使用Process模块创建进程

Process模块是一个创建进程的模块,借助这个模块,就可以完成进程的创建.

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

 

举例说明:

# 当前文件名称为test.py
# 引入Process模块
from multiprocessing import Process

def func():
    print("子进程正在运行")

if __name__ == ‘__main__‘:
    """由于系统创建进程机制的原因,windows下必须
    写if __name__ == ‘__main__‘语句"""
    p = Process(target=func,)
    """这一步骤将函数注册到一个进程中,p是一个进程对象,
    此时还没有启动进程,只是创建了一个进程对象.
    这里的func是不加括号的,因为加上括号函数就直接运行了"""
    p.start()
    """这一步骤告诉操作系统,给我开启一个进程,此时func函数
    就被我们新开启的这个进程执行了,而这个进程是我主进程运
    行过程中创建出来的,所以这个新创建的进程为主进程的子进程,
    主进程又可以称为这个新进程的父进程"""
    print("主进程执行完毕")
    """这是主进程的程序,上面开启的子进程的程序是和主进程的
    程序同时运行的,我们称为异步"""

举例说明

 

(1)主进程和子进程

上面说了，我们通过主进程创建的子进程是异步执行的，那么我们就验证一下，并且看一下子进程和主进程(也就是父进程)的ID号（讲一下pid和ppid，使用pycharm举例），来看看是否是父子关系。

import time
import os

# os.getpid()   获取自己进程的ID号
# os.getppid()  获取自己进程的父进程的ID号

from multiprocessing import Process

def func():
    print("*"*10)
    time.sleep(1)
    print("子进程ID>>>", os.getpid())
    print("子进程的父进程ID>>>", os.getppid())
    print("~"*10)

if __name__ == ‘__main__‘:
    p = Process(target=func,)
    p.start()
    print("@"*10)
    print("父进程ID>>>", os.getpid())
    print("父进程的父进程ID>>>", os.getppid())
    print("#"*10)
    
# @@@@@@@@@@
# 父进程ID>>> 9040
# 父进程的父进程ID>>> 6328
# ##########
# **********
# 子进程ID>>> 6872
# 子进程的父进程ID>>> 9040
# ~~~~~~~~~~

举例说明

从以上实例可以看出,首先打印出来的是主进程的ID号,然后打印的是子进程的ID号,也就是子进程是异步执行的,相当于主进程和子进程同时运行着.如果是同步的话,我们先执行的是func(),应该是子进程的ID先打印出来.显然,这与实际结果是矛盾的.于是可以得出"主进程创建的子进程是异步执行"这样的结论.

 

(2)if __name__ == "main"语句

在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来，import 的时候就不会递归运行了。

 

2. Process模块参数介绍

参数介绍：
1 group参数未使用，值始终为None
2 target表示调用对象，即子进程要执行的任务
3 args表示调用对象的位置参数元组，args=(1,2,‘egon‘,)
4 kwargs表示调用对象的字典,kwargs={‘name‘:‘egon‘,‘age‘:18}
5 name为子进程的名称

函数传参的两种方式:

import time
from multiprocessing import Process

def func(a, b, c):
    print("函数func的参数分别是>>>", a, b, c)
    print("子进程执行完毕!")

if __name__ == ‘__main__‘:
    p = Process(target=func, args=("参数一", "参数二", "参数三"))
    p.start()
    time.sleep(1)
    print("主进程执行完毕!")

# 执行结果是:
# 函数func的参数分别是>>> 参数一 参数二 参数三
# 子进程执行完毕!
# 主进程执行完毕!

函数传参的第一种方式

import time
from multiprocessing import Process

def func(a, b, c):
    print("函数func的参数分别是>>>", a, b, c)
    print("子进程执行完毕!")

if __name__ == ‘__main__‘:
    p = Process(target=func, kwargs={"a":"参数一", "b":"参数二", "c":"参数三"})
    p.start()
    time.sleep(1)
    print("主进程执行完毕!")

# 执行结果:
# 函数func的参数分别是>>> 参数一 参数二 参数三
# 子进程执行完毕!
# 主进程执行完毕!

函数传参的第二种方式

 

3. Process模块方法介绍

1 p.start()：启动进程，并调用该子进程中的p.run() 
2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  
3 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
4 p.is_alive():如果p仍然运行，返回True
5 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程  

 

(1)join方法的使用

import time
from multiprocessing import Process

def func():
    print("子进程开始执行!")
    time.sleep(1)
    print("子进程执行完毕!")

if __name__ == ‘__main__‘:
    print("主进程开始执行!")
    p = Process(target=func,)
    p.start()
    print("主进程执行完毕!")

# 执行结果:
# 主进程开始执行!
# 主进程执行完毕!
# 子进程开始执行!
# 子进程执行完毕!

实例1

import time
from multiprocessing import Process

def func():
    print("子进程开始执行!")
    time.sleep(1)
    print("子进程执行完毕!")

if __name__ == ‘__main__‘:
    print("主进程开始执行!")
    p = Process(target=func, )
    p.start()
    p.join()
    print("主进程执行完毕!")

# 执行结果:   
# 主进程开始执行!
# 子进程开始执行!
# 子进程执行完毕!
# 主进程执行完毕!

实例2

 

对比实例1和实例2的结果,可以发现,实例1的打印结果明显不符合正常的代码执行流程,竟然是:主进程开启并结束之后,子进程才开启并结束.出现这样的情况的原因是: 主进程开启后,随即便调用操作系统创建子进程(p = Process(target=func,))并开启子进程(p.start()). 然而,在创建和执行子进程的过程中,操作系统要进行相当复杂的操作(如分配资源),这些操作都是需要时间的,从而造成了主进程先于子进程执行完毕的现象.

但是join()方法可以完美地解决这个问题.在实例2中,当主进程执行到p.join()时,整个程序会阻塞在这里,直到子进程p执行完毕,主进程才能继续向下执行,也就不会出现主进程先于子进程执行完毕的现象了.

 (2)for循环开启多个进程

from multiprocessing import Process

def func(n):
    print(n)

if __name__ == ‘__main__‘:
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
    print("主进程执行完毕!")

# 执行结果:
# 0
# 2
# 1
# 3
# 4
# 主进程执行完毕!
# 5
# 6
# 7
# 8
# 9

实例1

from multiprocessing import Process
def func(n):
    print(n)

if __name__ == ‘__main__‘:
    pro_list = []
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
        pro_list.append(p)
    for p in pro_list:
        p.join()
    print("主进程结束!")
    
# 执行结果:
# 1
# 0
# 3
# 2
# 4
# 5
# 6
# 7
# 8
# 9
# 主进程结束!

实例1优化

 

模拟两个应用场景: 1.同时对一个文件进行写操作  2.同时创建多个文件

import time
import os
import re
from multiprocessing import Process
#多进程同时对一个文件进行写操作
def func(x,y,i):
    with open(x,‘a‘,encoding=‘utf-8‘) as f:
        print(‘当前进程%s拿到的文件的光标位置>>%s‘%(os.getpid(),f.tell()))
        f.write(y)

#多进程同时创建多个文件
# def func(x, y):
#     with open(x, ‘w‘, encoding=‘utf-8‘) as f:
#         f.write(y)

if __name__ == ‘__main__‘:

    p_list= []
    for i in range(10):
        p = Process(target=func,args=(‘can_do_girl_lists.txt‘,‘姑娘%s‘%i,i)) 
        # p = Process(target=func,args=(‘can_do_girl_info%s.txt‘%i,‘姑娘电话0000%s‘%i))
        p_list.append(p)
        p.start()

    [ap.join() for ap in p_list] #这就是个for循环，只不过用列表生成式的形式写的
    with open(‘can_do_girl_lists.txt‘,‘r‘,encoding=‘utf-8‘) as f:
        data = f.read()
        all_num = re.findall(‘d+‘,data) #打开文件，统计一下里面有多少个数据，每个数据都有个数字，所以re匹配一下就行了
        print(‘>>>>>‘,all_num,‘.....%s‘%(len(all_num)))
    #print([i in in os.walk(r‘你的文件夹路径‘)])
    print(‘不要钱~~~~~~~~~~~~~~~~！‘)
 

两个应用场景

 

4. Process模块方法介绍

1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2 p.name:进程的名称
3 p.pid：进程的pid
4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

 

5. 在windows中必须把Process()放到if __name__ == "main"语句下

由于Windows没有fork，多处理模块启动一个新的Python进程并导入调用模块。 
如果在导入时调用Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。 
这是隐藏对Process（）内部调用的原，使用if __name__ == “__main __”，这个if语句中的语句将不会在导入时被调用。

 

 

二. Process类的使用

1. 继承的形式创建进程

# 自定义一个类,继承Process类,必须写一个run()方法.如果想要传参,可以自己写一个init方法,然后首先执行super父类的init方法,再写自己的属性.
from multiprocessing import Process

class MyProcess(Process):   # 自定义的类要继承Process类
    def __init__(self, n, name):
        super().__init__()  # 如果自己想要传参name, 那么要首先用super()执行父类的init方法
        self.n = n
        self.name = name
    def run(self):
        print("子进程的名字是>>>", self.name)
        print("n的值是>>>", self.n)

if __name__ == ‘__main__‘:
    p1 = MyProcess(123, name="子进程01")
    p1.start()  # 给操作系统发送创建进程的指令,子进程创建好之后,要被执行,执行的时候就会执行run方法
    print("p1.name是>>>", p1.name)
    print("主进程结束")

# 执行结果:
# p1.name是>>> 子进程01
# 主进程结束
# 子进程的名字是>>> 子进程01
# n的值是>>> 123

类继承的方式创建进程

 

2. 进程的内存空间是隔离的

import time
from multiprocessing import Process

global_num = 100
def func():    # 子进程
    global global_num
    global_num = 0
    print("子进程的全局变量>>>", global_num)

if __name__ == ‘__main__‘:
    p1 = Process(target=func,)
    p1.start()
    time.sleep(1)  # 等待子进程执行结束
    print("主进程的全局变量>>>", global_num)

# 执行结果:
# 子进程的全局变量>>> 0
# 主进程的全局变量>>> 100

# 得出结论:
# 进程之间是空间隔离的,不共享资源

验证进程之间是空间隔离的

 

3. Process对象的其他方法或属性

from multiprocessing import Process
import time

def func():
    print("子进程开始执行!")
    time.sleep(2)
    print("子进程执行完毕!")

if __name__ == ‘__main__‘:
    p = Process(target=func,)
    p.start()
    p.terminate()  # 给操作系统发送一个关闭进程p1的信号,让操作系统去关闭它
    time.sleep(1)
    """由于操作系统关闭子进程的过程需要做许多事情(如回收资源),这是需要耗费一定时间的,
    如果在给操作系统发出关闭信号后(p1.terminate())立刻判断子进程是否还活着,结果是不准
    确的,此时操作系统正在关闭子进程,所以我们要等待一定时间才可以得到正确的判断结果."""
    print("子进程是否还活着>>>", p.is_alive())
    print("主进程执行完毕!")

terminate和is_alive

from multiprocessing import Process

def func():
    print("子进程开始执行!")

if __name__ == ‘__main__‘:
    p = Process(target=func,)
    p.start()
    p.join()
    print("子进程的ID是>>>", p.pid)
    print("子进程的名字是>>>", p.name)
    print("主进程执行完毕!")
    
# 执行结果:
# 子进程开始执行!
# 子进程的ID是>>> 4292
# 子进程的名字是>>> Process-1
# 主进程执行完毕!

进程名和进程ID

 

4. 子进程中不能有input

如果在子进程中存在input,由于输入台只显示在主进程中,子进程是没有输入台的,于是系统会自动报错.所以不要在子进程中出现input.

5. 僵尸进程和孤儿进程

(1)僵尸进程(有害):

任何一个子进程(init除外)在exit()之后，并非马上就消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。这是每个子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时 处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。 如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。

例如有个进程，它定期的产 生一个子进程，这个子进程需要做的事情很少，做完它该做的事情之后就退出了，因此这个子进程的生命周期很短，但是，父进程只管生成新的子进程，至于子进程 退出之后的事情，则一概不闻不问，这样，系统运行上一段时间之后，系统中就会存在很多的僵死进程，倘若用ps命令查看的话，就会看到很多状态为Z的进程。 严格地来说，僵死进程并不是问题的根源，罪魁祸首是产生出大量僵死进程的那个父进程。因此，当我们寻求如何消灭系统中大量的僵死进程时，答案就是把产生大 量僵死进程的那个元凶枪毙掉（也就是通过kill发送SIGTERM或者SIGKILL信号啦）。枪毙了元凶进程之后，它产生的僵死进程就变成了孤儿进 程，这些孤儿进程会被init进程接管，init进程会wait()这些孤儿进程，释放它们占用的系统进程表中的资源，这样，这些已经僵死的孤儿进程 就能瞑目而去了。

僵尸进程危害场景

(2)孤儿进程(无害)

孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。

 

三. 守护进程

使用平常的方法时,子进程是不会随着主进程的结束而结束,只有当主进程和子进程全部执行完毕后,程序才会结束.但是,如果我们的需求是: 主进程执行结束,由该主进程创建的子进程必须跟着结束. 这时,我们就需要用到守护进程了.

主进程创建守护进程:

　　　　其一: 守护进程会在主进程代码执行结束后就终止

　　　　其二:守护进程内无法再开启子进程,否则抛出异常: AssertionError: daemonic processes are not allowed to have children

需要注意的是: 进程之间是相互独立的,主进程代码运行结束,守护进程随机终止.

import os
import time
from multiprocessing import Process

class Myprocess(Process):
    def __init__(self,person):
        super().__init__()
        self.person = person
    def run(self):
        print("这个人的ID号是:%s" % os.getpid())
        print("这个人的名字是:%s" % self.name)
        time.sleep(3)
if __name__ == ‘__main__‘:
    p=Myprocess(‘李华‘)
    p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
    p.start()
    # time.sleep(1) # 在sleep时linux下查看进程id对应的进程ps -ef|grep id
    print(‘主进程执行完毕!‘)    

守护进程