码迷,mamicode.com
首页 > 编程语言 > 详细

Python multiprocess模块

时间:2018-10-24 01:11:16      阅读:143      评论:0      收藏:0      [点我收藏+]

标签:大量   start   进程启动   元组   两种   严格   方法   kill   16px   

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(主进程执行完毕!)    
守护进程

 

Python multiprocess模块

标签:大量   start   进程启动   元组   两种   严格   方法   kill   16px   

原文地址:https://www.cnblogs.com/haitaoli/p/9837697.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!