简单介绍python process模块

287次阅读

共计 3926 个字符，预计需要花费 10 分钟才能阅读完成。

导读	在 python 中大部分情况需要使用多进程，python 提供了 multiprocessing 模块。multiprocessing 模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了 Process、Queue、Pipe、Lock 等组件。本文将着重讲解 process 模块的使用

process 模块

process 模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。

参数介绍：

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

方法介绍：

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

属性介绍：

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

1、在 python 中启动一个子进程

from multiprocessing import Process
import os

def func():
    print('这是一个子进程——> 进程号：', os.getpid(), '主进程号：', os.getppid())


if __name__ == '__main__':
    print('这是主进程——> 进程号：', os.getpid(), '主进程号（pycharm）：', os.getppid())
    # 实例化一个子进程对象
    obj = Process(target=func)
    obj.start()     # 执行子进程对象
    print('执行了完了主进程的内容')

# 输出
这是主进程——> 进程号：3100   主进程号（pycharm）：6748
执行了完了主进程的内容
这是一个子进程——> 进程号：2392   主进程号：3100

2、给子进程传递参数

from multiprocessing import Process
import os


def func(name, age):
    print('这是一个子进程——> 进程号：', os.getpid(), '主进程号：', os.getppid())
    print(f'这是一个子进程——> 我的名字是{name}，今年{age}')


if __name__ == '__main__':
    print('这是主进程——> 进程号：', os.getpid(), '主进程号（pycharm）：', os.getppid())
    # 实例化一个子进程对象
    obj = Process(target=func, args=('小杨', '18')) # args 以元组的形式给子进程 func 函数传位置参数
                               # kwargs 以字典的形式给子进程 func 函数传关键字参数
                               # kwargs={'name': '小杨', 'age': 18}
    obj.start()     # 执行子进程对象
    print('执行了完了主进程的内容')
     
# 输出
这是主进程——> 进程号：11936   主进程号（pycharm）：3676
执行了完了主进程的内容
这是一个子进程——> 进程号：2996   主进程号：11936
这是一个子进程——> 我的名字是小杨，今年 18

3、同时开多个子进程

from multiprocessing import Process
import os


def func(name, age):
    print(f'这是一个子进程——> 进程号：{os.getpid()}, 主进程号：{os.getppid()}, 我的名字是{name}，今年{age}')


if __name__ == '__main__':
    print('这是主进程——> 进程号：', os.getpid(), '主进程号（pycharm）：', os.getppid())
    count = [('小杨', 18), ('鲍勃', 20), ('艾伦', 55)]
    for lis in count:
        # 实例化一个子进程对象
        obj = Process(target=func, args=lis)   # args 以元组的形式给子进程 func 函数传位置参数
        obj.start()     # 执行子进程对象
    print('执行了完了主进程的内容')
     
# 输出
这是主进程——> 进程号：12632   主进程号（pycharm）：9220
执行了完了主进程的内容
这是一个子进程——> 进程号：10048, 主进程号：12632, 我的名字是小杨，今年 18
这是一个子进程——> 进程号：16032, 主进程号：12632, 我的名字是鲍勃，今年 20
这是一个子进程——> 进程号：12060, 主进程号：12632, 我的名字是艾伦，今年 55

4、join 的用法

obj.join([timeout]): 主进程等待子进程 obj 终止（强调：是主进程处于等的状态，而子进程 obj 是处于运行的状态）。timeout 是可选的超时时间，需要强调的是，obj.join 只能 join 住 start 开启的进程，而不能 join 住 run 开启的进程

多个进程同时运行（注意，子进程的执行顺序不是根据启动顺序决定的）

join——> 属于同步阻塞：

同步：在做 A 事件的时候发起 B 事件，必须等待 B 事件结束后才能继续做 A 事件

阻塞：CPU 不工作——>input accept recv recvfrom sleep connect……

start——> 属于异步非阻塞：

异步：在做 A 事件的时候发起 B 事件，不用等待 B 事件结束就可以继续 A 事件

非阻塞：CPU 在工作（非输入输出阶段 I /O）

from multiprocessing import Process
import random
import time


def mail(name, age):
    count = random.random()
    print(f'给 {age} 岁的 {name} 发了一封邮件！延迟 {count} 秒')
    time.sleep(count)      # 模拟网络延迟
    """多个进程同时运行（注意，子进程的执行顺序不是根据启动顺序决定的）"""


if __name__ == '__main__':
    info_list = [('小杨', 18), ('鲍勃', 20), ('艾伦', 55)]
    jo = []
    for info in info_list:
        obj = Process(target=mail, args=info)
        obj.start()
        jo.append(obj)

    # 将所有的子进程全部放入 jo 列表，在循环 join 所有子进程，就能等待所有子进程结束后在做操作
    for o in jo:
        o.join()

    # 所有的子进程结束的操作
    print('全部发送完毕')
     
# 输出
给 20 岁的鲍勃发了一封邮件！延迟 0.19840279388911186 秒
给 18 岁的小杨发了一封邮件！延迟 0.8891892863366903 秒
给 55 岁的艾伦发了一封邮件！延迟 0.0434307277609951 秒
全部发送完毕

5、多进程之间的数据是否隔离

from multiprocessing import Process

count = 1

def func():
    global count
    count += 1

if __name__ == '__main__':
    for i in range(10):
        obj = Process(target=func)
        obj.start()
    print(count)        # ————>1 主进程的 count 没有被改变说明进程之间的数据时隔离的
     
# 输出
1

6、为什么在 Windows 中 Process（）必须放到 if __name__ == ‘__main__’: 下

由于 Windows 没有 fork，多处理模块启动一个新的 Python 进程并导入调用模块。

如果在导入时调用 Process（），那么这将启动无限继承的新进程（或直到机器耗尽资源）。

这是隐藏对 Process（）内部调用的原，使用 if __name__ == ‘__main__’:，这个 if 语句中的语句将不会在导入时被调用。

以上就是 python process 模块的使用简介的详细内容。