多进程 multiprocess模块

发表于 | 分类于


开启多进程

使用Process模块

1
2
3
4
5
6
# Process([group [, target [, name [, args [, kwargs]]]]])
# target表示调用对象，你可以传入方法的名字
# args表示被调用对象的位置参数元组，比如target是函数a，他有两个参数m，n，那么args就传入(m, n)即可
# kwargs表示调用对象的字典
# name是别名，相当于给这个进程取一个名字
# group分组，实际上不使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 使用process模块
from multiprocessing import Process
import multiprocessing
import os

def process(num):
    print('PID:%s Process:%s' %(os.getpid(),num))
if __name__ == '__main__':
    for i in range(5):
        p = Process(target=process,args=(i,))
        p.start()
    print('CPU number:%d' %multiprocessing.cpu_count()) # cpu个数
    
# CPU number:4
# PID:97764 Process:1
# PID:101312 Process:2
# PID:100472 Process:0
# PID:101172 Process:4
# PID:99964 Process:3

继承Process类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 继承创建多进程
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self):
        super().__init__()

    def run(self):
        print('开始一个新进程 PID:%s' %self.pid)

if __name__ == '__main__':
    for i in range(5):
        p = MyProcess()
        p.start()

# 开始一个新进程 PID:100524
# 开始一个新进程 PID:97824
# 开始一个新进程 PID:87880
# 开始一个新进程 PID:93100
# 开始一个新进程 PID:94960

守护进程 deamon

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 如果设置为True，当父进程结束后，子进程会自动被终止。
# 注意: 守护进程 会随着 主进程的代码执行完毕 而结束
# 代码运行: 主进程 在延迟一秒后只打印一句话，全部的代码已经执行完成,也直接终止了子进程的运行
# 作用: 有效防止无控制地生成子进程，关闭这个主程序运行时，就无需额外担心子进程有没有被关闭了。
import time
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self):
        super().__init__()
    def run(self):
        time.sleep(2)
        print('开启一个新进程%s' %self.pid)

if __name__ == '__main__':
    for i in range(5):
        p = MyProcess()
        p.daemon = True
        p.start()

    time.sleep(1)
    print('主进程结束')
    # time.sleep(3) # 如果再延迟3秒，子进程会执行，因为这个时候主进程的代码还没有执行结束
    
# 主进程结束

主进程等待子进程执行完成 join

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 主进程等待子进程执行完成 join
# 每个子进程都调用了join()方法，这样父进程（主进程）就会等待子进程执行完毕。
import os
import time
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,num):
        super().__init__()
        self.num = num
    def run(self):
        time.sleep(1)
        print('子进程%s 任务编号%s 开始执行' %(os.getpid(),self.num))

if __name__ == '__main__':
    start_time = time.time()
    p_lst = []
    for i in range(1,6):
        p = MyProcess(i)
        p_lst.append(p)
        p.daemon = True
        p.start()
        # p.join()              # 如果在循环里面join,则每循环一个进程都要等待进程的结束,会变成同步
    [p.join() for i in p_lst]   # 之前的所有进程必须在这里都执行完，才能执行后面的代码

    print('主进程执行结束')
    print('程序运行:',time.time()-start_time)
    
# 子进程55888 任务编号3 开始执行
# 子进程16812 任务编号4 开始执行
# 子进程77500 任务编号1 开始执行
# 子进程62216 任务编号5 开始执行
# 子进程86548 任务编号2 开始执行
# 主进程执行结束
# 程序运行: 1.2200696468353271