• Process的join用法

Process的join用法

为什么会有这个方法呢？

是这样的如果我有一个需求就是子进程运行完了在运行主进程，那么这个该如何实现？

第一种方式就是用time模块

# 这里有一个需求就是子进程运行完在运行主进程，这个该如何实现？
#方式一:用time模块，虽然可以，但是每个电脑的反应时间是不一样的，这个方法太low了
from multiprocessing import Process

import time

def foo():
    print('进程 start')
    time.sleep(2)
    print('进程 end')


if __name__ == '__main__':
    p = Process(target=foo)
    p.start()
    time.sleep(2)
    print('主进程')

这个方式确实可以实现但是每个电脑的反应时间是不一样的，如果用time就要算反应时间很麻烦而且太low了

第二种方式就是join方法了

join方法就类似停止，但是它会把主进程进行阻塞，直到调用join方法的子进程执行完毕，然后主进程才能执行。

(同时需要注意一点，视频里有一处地方让人以为这个方法具有停止的功能，但是没有这个功能切记切记)

join代码如下

import time
from multiprocessing import Process


def foo(x, y):
    print(f'进程开始{x}')
    time.sleep(y)
    print(f'进程{x}结束')


if __name__ == '__main__':
    p1 = Process(target=foo, args=(1, 2))  # 这里面的args就是*args的一种体现，这个args里面我传的第一个参数1是给子进程用来命名，第二个参数给time.sleep传参数来确定睡眠时间
    p2 = Process(target=foo, args=(2, 2))  # 这里的args和上面的情况一样
    p3 = Process(target=foo, args=(3, 2))  # 这里的args和上面的情况一样
    p4 = Process(target=foo, args=(4, 2))  # 这里的args和上面的情况一样

    start = time.time()  # 这里来添加一个读取开始时间的代码

    p1.start()  # 这里告诉操作系统开启子进程
    p1.join()  # p1这个子进程调用join这个方法让主进程阻塞

    p2.start()  # 和p1的情况一样
    p2.join()  # 和p1的情况一样

    p3.start()
    p3.join()

    p4.start()
    p4.join()

    # 阻塞住主进程，等待该子进程结束，然后在执行主进程，看似是join方法实际内部会调用wait()

    # 这里添加一个读取结束时间的代码

    end = time.time()  # 这里添加一个读取结束时间的代码

    print(end - start)  # 这里输出总时长的值

    print('主进程')

这个代码p1 = Process(target=foo, args=(1, 2))里的args就是*args的一种体现，这个args里面我传的第一个参数1是给子进程用来命名，第二个参数给time.sleep传参数来确定睡眠时间

结果如图

结果就体现了join()方法的用法了。

这里提一个情况，上面我用的是join方法但实际上我使用了wait方法。

wait()方法是用于等待子进程结束的低级方法。当调用join()时，它实际上在内部调用wait()来等待子进程的结束。

然后这个方法被封装在join内，同时这个方法比较依赖操作系统

给上面的代码略微升级添加for循环来使用来减少冗余

import time
from multiprocessing import Process


def foo(x, y):
    print(f'进程开始{x}')
    time.sleep(y)
    print(f'进程{x}结束')


if __name__ == '__main__':
    start = time.time()
    p_list = []

    for i in range(1,4):#这里省去给函数传参时代码冗余的情况
        p = Process(target=foo, args=(i, 1))
        p.start()
        p_list.append(p)#将生成的子进程添加到这个p_list的列表里面

    print(p_list)

    for p in p_list:#这里让列表里面的子进程来分别调用join()方法
        p.join()
    end = time.time()
    print(end - start)
    print('主进程')

这个代码就解决了，向操作系统申请开启子进程以及每个子进程调用join()方法冗余的情况

结果如下

这种方式就更利于代码的简便