Python基础之多进程

目录

• 1 多进程
  • 1.1 简介
  • 1.2 Linux下多进程
  • 1.3 multiprocessing
  • 1.4 Pool
    • 1.4.1 进程池 multiprocessing
    • 1.4.2 线程池 multiprocessing.dummy
    • 1.4.3 multiprocessing.dummy 和 multiprocessing 区别
  • 1.5 进程间通信
  • 1.6 分布式进程

1 多进程

1.1 简介

要让Python程序实现多进程（multiprocessing），我们先了解操作系统的相关知识。
Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程和子进程内返回。

子进程永远返回0，而父进程返回子进程的ID。这样做的理由是，一个父进程可以fork出很多子进程，所以，父进程要记下每个子进程的ID，而子进程只需要调用getppid()就可以拿到父进程的ID。

1.2 Linux下多进程

Python的os模块封装了常见的系统调用，其中就包括fork，可以在Python程序中轻松创建子进程：

# multiprocessing.py
import os

print ('Process (%s) start...' % os.getpid())
pid = os.fork()
if pid==0:
    print ('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
    print 'I (%s) just created a child process (%s).' % (os.getpid(), pid)
运行结果如下：

Process (876) start...
I (876) just created a child process (877).
I am child process (877) and my parent is 876.

由于Windows没有fork调用，上面的代码在Windows上无法运行。由于Mac系统是基于BSD（Unix的一种）内核，所以，在Mac下运行是没有问题的

有了fork调用，一个进程在接到新任务时就可以复制出一个子进程来处理新任务，常见的Apache服务器就是由父进程监听端口，每当有新的http请求时，就fork出子进程来处理新的http请求。

1.3 multiprocessing

如果打算编写多进程的服务程序，Unix/Linux无疑是正确的选择。由于Windows没有fork调用，难道在Windows上无法用Python编写多进程的程序？
由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。

multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：

from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
    print ('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print ('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print ('Process will start.')
    p.start()
    p.join()
    print 'Process end.'

执行结果如下：
Parent process 928.
Process will start.
Run child process test (929)...
Process end.

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动，这样创建进程比fork()还要简单。
join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。

1.4 Pool

1.4.1 进程池 multiprocessing

如果要启动大量的子进程，可以用进程池的方式批量创建子进程：

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()
    for i in range(5):
        p.apply_async(long_time_task, args=(i,))
    print ('Waiting for all subprocesses done...')
    p.close()
    p.join()
    print 'All subprocesses done.'

执行结果如下：
Parent process 669.
Waiting for all subprocesses done...
Run task 0 (671)...
Run task 1 (672)...
Run task 2 (673)...
Run task 3 (674)...
Task 2 runs 0.14 seconds.
Run task 4 (673)...
Task 1 runs 0.27 seconds.
Task 3 runs 0.86 seconds.
Task 0 runs 1.41 seconds.
Task 4 runs 1.91 seconds.
All subprocesses done.

代码解读：

• 对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。
• 注意输出的结果，task 0，1，2，3是立刻执行的，而task 4要等待前面某个task完成后才执行，这是因为Pool的默认大小在电脑上是4，因此，最多同时执行4个进程。这是Pool有意设计的限制，并不是操作系统的限制。如果改成：p = Pool(5)，就可以同时跑5个进程。
• 由于Pool的默认大小是CPU的核数，如果拥有8核CPU，那么要提交至少9个子进程才能看到上面的等待效果。

1.4.2 线程池 multiprocessing.dummy

导入线程池使用：from multiprocessing.dummy import Pool
如下操作，就是使用线程池后大概2秒

import time
# 导入线程池
from multiprocessing.dummy import Pool
start_time=time.time()
def get_page(str):
    print('正在下载：',str)
    time.sleep(2)
    print('下载成功：',str)

name_list=['xiaozi','aa','bb','cc']
# 实例化一个线程池
pool=Pool(4)
# 第一个参数是要阻塞的函数，第二个参数是可迭代对象
# 如果第一个参数即阻塞函数有返回值，那么就会通过map返回回去
pool.map(get_page,name_list)
pool.close()
end_time=time.time()

print(f'消耗时间secode:{end_time-start_time}')

1.4.3 multiprocessing.dummy 和 multiprocessing 区别

在 Python 中，multiprocessing 模块提供了支持进程间并行计算的接口，而 multiprocessing.dummy 模块则是一个提供了与 multiprocessing 相同接口的线程池（ThreadPool）实现。这两个模块都提供了Pool类，但它们在使用上存在一些关键的区别，主要体现在它们使用的并行机制上：

• multiprocessing.Pool：
  • multiprocessing 模块是Python标准库的一部分，它支持使用进程（processes）来并行地执行Python代码。每个进程都拥有独立的Python解释器实例和内存空间，这意味着它们可以真正地并行执行，并且不受全局解释器锁（GIL, Global Interpreter Lock）的限制。这对于CPU密集型任务特别有用，因为你可以利用多核CPU的优势来加速计算。
  • 使用进程（Process）来并行执行任务。这意味着每个任务都会在其自己的Python解释器进程中运行，这些进程之间通过操作系统提供的机制进行通信（如管道、消息队列等）。
  • 进程间的内存是隔离的，因此每个进程都有自己的内存空间。这意味着你不能直接在进程间共享数据（除非使用特殊的机制，如multiprocessing.Value、multiprocessing.Array、multiprocessing.Manager等）。
  • 由于进程间通信（IPC）和进程创建的开销，multiprocessing.Pool 可能不适合执行非常短的任务，但非常适合CPU密集型任务，因为它能够充分利用多核CPU的并行计算能力。
• multiprocessing.dummy.Pool：
  • multiprocessing.dummy 模块是一个包装器，它实际上使用了 threading 模块（即线程）来模拟 multiprocessing 的行为。这意味着虽然它提供了与 multiprocessing 相似的API，但底层使用的是线程而不是进程。线程共享同一个进程的内存空间，因此它们之间的通信和数据共享比进程间通信要简单得多。然而，由于GIL的存在，Python线程在执行CPU密集型任务时并不能真正并行执行，它们主要用于I/O密集型任务或等待密集型任务（如网络请求、文件读写等）。
  • 线程之间共享同一个进程的内存空间，因此可以很方便地共享数据，但这也意味着需要处理线程安全问题（如使用锁、信号量等同步机制）。
  • 由于线程间切换的开销远小于进程间通信和进程创建的开销，multiprocessing.dummy.Pool（即线程池）非常适合执行I/O密集型任务或非常短的任务，因为它可以更快地响应和切换任务。

主要区别：

• 底层机制：multiprocessing 使用进程，而 multiprocessing.dummy 使用线程。
• 并行性：multiprocessing 可以利用多核CPU进行真正的并行计算，而 multiprocessing.dummy 由于GIL的限制，在CPU密集型任务上无法提供真正的并行性。
• 适用场景：multiprocessing 更适合CPU密集型任务，而 multiprocessing.dummy（即使用线程）更适合I/O密集型任务。
• 通信与同步：进程间通信（IPC）通常比线程间通信更复杂，因为进程有独立的内存空间。然而，对于 multiprocessing.dummy 来说，由于它使用线程，所以通信和同步相对简单。

总结：

• multiprocessing.Pool 适用于需要在多个CPU核心上并行处理CPU密集型任务的场景。
• multiprocessing.dummy.Pool 适用于需要并发处理I/O密集型任务的场景，实质上是使用多线程实现。

1.5 进程间通信

Process之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。

我们以 Queue 为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
    for value in ['A', 'B', 'C']:
        print ('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())
# 读数据进程执行的代码:
def read(q):
    while True:
        value = q.get(True)
        print ('Get %s from queue.' % value)

if __name__=='__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()

运行结果如下：

Put A to queue...
Get A from queue.
Put B to queue...
Get B from queue.
Put C to queue...
Get C from queue.

在Unix/Linux下，multiprocessing模块封装了fork()调用，使我们不需要关注fork()的细节。由于Windows没有fork调用，因此，multiprocessing需要“模拟”出fork的效果，父进程所有Python对象都必须通过pickle序列化再传到子进程去，所以，如果multiprocessing在Windows下调用失败了，要先考虑是不是pickle失败了。

1.6 分布式进程

Python的multiprocessing模块不但支持多进程，其中managers子模块还支持把多进程分布到多台机器上。一个服务进程可以作为调度者，将任务分布到其他多个进程中，依靠网络通信。

举个例子：如果我们已经有一个通过Queue通信的多进程程序在同一台机器上运行，现在，由于处理任务的进程任务繁重，希望把发送任务的进程和处理任务的进程分布到两台机器上。怎么用分布式进程实现？
原有的Queue可以继续使用，但是，通过managers模块把Queue通过网络暴露出去，就可以让其他机器的进程访问Queue了。
我们先看服务进程，服务进程负责启动Queue，把Queue注册到网络上，然后往Queue里面写入任务：

# taskmanager.py

import random, time, Queue
from multiprocessing.managers import BaseManager

# 发送任务的队列:
task_queue = Queue.Queue()
# 接收结果的队列:
result_queue = Queue.Queue()

# 从BaseManager继承的QueueManager:
class QueueManager(BaseManager):
    pass

# 把两个Queue都注册到网络上, callable参数关联了Queue对象:
QueueManager.register('get_task_queue', callable=lambda: task_queue)
QueueManager.register('get_result_queue', callable=lambda: result_queue)
# 绑定端口5000, 设置验证码'abc':
manager = QueueManager(address=('', 5000), authkey='abc')
# 启动Queue:
manager.start()
# 获得通过网络访问的Queue对象:
task = manager.get_task_queue()
result = manager.get_result_queue()
# 放几个任务进去:
for i in range(10):
    n = random.randint(0, 10000)
    print('Put task %d...' % n)
    task.put(n)
# 从result队列读取结果:
print('Try get results...')
for i in range(10):
    r = result.get(timeout=10)
    print('Result: %s' % r)
# 关闭:
manager.shutdown()

请注意，当我们在一台机器上写多进程程序时，创建的Queue可以直接拿来用，但是，在分布式多进程环境下，添加任务到Queue不可以直接对原始的task_queue进行操作，那样就绕过了QueueManager的封装，必须通过manager.get_task_queue()获得的Queue接口添加。
然后，在另一台机器上启动任务进程（本机上启动也可以）：

# taskworker.py

import time, sys, Queue
from multiprocessing.managers import BaseManager

# 创建类似的QueueManager:
class QueueManager(BaseManager):
    pass

# 由于这个QueueManager只从网络上获取Queue，所以注册时只提供名字:
QueueManager.register('get_task_queue')
QueueManager.register('get_result_queue')

# 连接到服务器，也就是运行taskmanager.py的机器:
server_addr = '127.0.0.1'
print('Connect to server %s...' % server_addr)
# 端口和验证码注意保持与taskmanager.py设置的完全一致:
m = QueueManager(address=(server_addr, 5000), authkey='abc')
# 从网络连接:
m.connect()
# 获取Queue的对象:
task = m.get_task_queue()
result = m.get_result_queue()
# 从task队列取任务,并把结果写入result队列:
for i in range(10):
    try:
        n = task.get(timeout=1)
        print('run task %d * %d...' % (n, n))
        r = '%d * %d = %d' % (n, n, n*n)
        time.sleep(1)
        result.put(r)
    except Queue.Empty:
        print('task queue is empty.')
# 处理结束:
print('worker exit.')

任务进程要通过网络连接到服务进程，所以要指定服务进程的IP。

现在，可以试试分布式进程的工作效果了。先启动taskmanager.py服务进程：

$ python taskmanager.py
Put task 3411...
Put task 1605...
Put task 1398...
Put task 4729...
Put task 5300...
Put task 7471...
Put task 68...
Put task 4219...
Put task 339...
Put task 7866...
Try get results...
taskmanager进程发送完任务后，开始等待result队列的结果。现在启动taskworker.py进程：

$ python taskworker.py 127.0.0.1
Connect to server 127.0.0.1...
run task 3411 * 3411...
run task 1605 * 1605...
run task 1398 * 1398...
run task 4729 * 4729...
run task 5300 * 5300...
run task 7471 * 7471...
run task 68 * 68...
run task 4219 * 4219...
run task 339 * 339...
run task 7866 * 7866...
worker exit.

taskworker进程结束，在taskmanager进程中会继续打印出结果：

Result: 3411 * 3411 = 11634921
Result: 1605 * 1605 = 2576025
Result: 1398 * 1398 = 1954404
Result: 4729 * 4729 = 22363441
Result: 5300 * 5300 = 28090000
Result: 7471 * 7471 = 55815841
Result: 68 * 68 = 4624
Result: 4219 * 4219 = 17799961
Result: 339 * 339 = 114921
Result: 7866 * 7866 = 61873956

这个简单的Manager/Worker模型有什么用？其实这就是一个简单但真正的分布式计算，把代码稍加改造，启动多个worker，就可以把任务分布到几台甚至几十台机器上，比如把计算n*n的代码换成发送邮件，就实现了邮件队列的异步发送。

Queue对象存储在哪？注意到taskworker.py中根本没有创建Queue的代码，所以，Queue对象存储在taskmanager.py进程中：

而Queue之所以能通过网络访问，就是通过QueueManager实现的。由于QueueManager管理的不止一个Queue，所以，要给每个Queue的网络调用接口起个名字，比如get_task_queue。

authkey：是为了保证两台机器正常通信，不被其他机器恶意干扰。如果taskworker.py的authkey和taskmanager.py的authkey不一致，肯定连接不上。

注意：Queue的作用是用来传递任务和接收结果，每个任务的描述数据量要尽量小。比如发送一个处理日志文件的任务，就不要发送几百兆的日志文件本身，而是发送日志文件存放的完整路径，由Worker进程再去共享的磁盘上读取文件。