Python多进程

Python中进程创建方式有两种:

fork:使用Python提供的os模块。

pid = os.fork();
pid即为创建出的子进程

Python在创建进程时会返回两次;一般方法只返回一次,Python分别在子进程、父进程中分别返回创建出的进程的ID。

Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，
但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），
然后，分别在父进程和子进程内返回。

子进程返回的ID一直为0

父进程返回的ID则是创建出的进程ID，父进程会保存该ID。

pid = os.fork();
if pid == 0:
    print('我是子进程我的编号是%1s,我的父进程的编号是%2s' % (os.getpid(), os.getppid()))
else:
    print('我是父进程我的编号是%1s,我刚刚创建了一个子进程,编号是%2s' % (os.getpid(), pid))

输出结果:

我是子进程我的编号是12688,我的父进程的编号是12687
我是父进程我的编号是12687,我刚刚创建了一个子进程,编号是12688

2.使用multiprocessing模块提供的Process、Pool 动态批量创建进程

为什么又要提出一个multiprocessing模块创建进程,单单fork不就OK。

因为。。。因为windows不支持直接fork进程。(划重点,这个要考)而linux/Unix系列支持。(所以,人生苦短,使用mac学习Python)

使用Process创建也很简单。

# 使用process对象进行创建进程

def run_proc(name):
    print('创建进程的名字为%s' % (name))


if __name__ == '__main__':
    print('-----------------------')
    print('创建子进程的父进程ID是%s' % (os.getpid()))
    #run_proc 是进程需要执行的任务的方法名
    #args 是run_proc方法需要的参数
    p = Process(target=run_proc, args=('test',))
    p.start()
    p.join()
    print('执行完了')

运行结果:

-----------------------
创建进程的名字为test
执行完了

创建成功之后,直接p.start()

p.join()用作进程同步(线程中也要用到这个方法)。意为进程此时等待，直到子进程执行完,再继续执行后续代码。

这样就实现了创建进程的代码。很清晰,很清晰,很简单。

接下来,就要进入高级的多进程创建了。

Pool

如果你有多进程的需求,就不要使用上述一个一个的创建了,

使用multiprocessing提供的Pool进程池进行多进程的创建。安全,文明,优雅。

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))


if __name__ == '__main__':
    print('Parent process %s.' % os.getpid())
    p = Pool(2)
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    # 必须要先进行close,然后才能进行join()
    p.close()
    p.join()
    print('All subprocesses done.')

执行结果:


Parent process 12917.
Waiting for all subprocesses done...
Run task 0 (12920)...
Run task 1 (12921)...
Waiting for all subprocesses done...
Run task 0 (12922)...
Run task 1 (12923)...
Task 1 runs 0.29 seconds.
Run task 2 (12923)...
Task 1 runs 0.96 seconds.
Run task 2 (12921)...
Task 0 runs 1.01 seconds.
Run task 3 (12920)...
Task 2 runs 1.03 seconds.
Run task 4 (12921)...
Task 3 runs 1.17 seconds.
Task 0 runs 2.22 seconds.
Run task 3 (12922)...
Task 2 runs 2.13 seconds.
Run task 4 (12923)...
Task 4 runs 1.87 seconds.
All subprocesses done.

直接使用p = Pool(2)创建一个进程数为2的进程池。

p.apply_async(long_time_task, args=(i,))

将待执行的任务与进程绑定apply_async。

p.close():

对Pool对象调用join()方法会等待所有子进程执行完毕，
调用join()之前必须先调用close()，
调用close()之后就不能继续添加新的Process了。

项目源码

Python多进程