1 模块简介
multiprocessing模块在Python2.6中引入。最初的multiprocessing是由Jesse Noller和Richard Oudkerk在PEP 371中定义。就像你可以在threading模块中使用多个线程一样，multiprocessing模块允许你使用多个进程。当你使用多个进程时，你可以避免GIL锁，并充分利用机器的多处理器。
multiprocessing库包括一些没有在threading模块中出现的API。例如，你可以使用Pool类在多个输入上并行执行一个函数。我们将在后面的章节提到Pool。我们先从multiprocessing中的Process类开始。
2 模块使用
2.1 开始使用Multiprocessing
Process类与threading中的Thread类非常相似。让我们尝试着创建多个进程，这些进程都会调用同一个函数，让我们看看它们是如何工作的，
import os
from multiprocessing import Process
def doubler(number):
result = number * 2
proc = os.getpid()
print("{0} double to {1} by process id:{2}\n".format(number,result,proc))
if __name__ == "__main__":
numbers = [5,10,15,20,25]
procs = []
for index,number in enumerate(numbers):
proc = Process(target = doubler,args = (number,))
procs.append(proc)
proc.start()
for proc in procs:
proc.join()
这个例子中，我们引入Process，然后创建一个doubler函数。在doubler函数中，我们将传入的数乘以2。我们也使用Python的os模块用于获取当前进程的ID（或者为pid）。这将会告诉我们哪个进程正在调用函数。在代码的底部，我们创建了多个线程，并且启动它们。最后一个循环就是在每个进程上调用join()方法，这个将会告诉Python需要等待进程终止。如果你需要终止终止一个进程，你可以调用terminate()方法。
当你运行这段代码时，你将会看到与以下结果相似的信息，
5 double to 10 by process id:6725
10 double to 20 by process id:6726
20 double to 40 by process id:6728
15 double to 30 by process id:6727
25 double to 50 by process id:6729
有时候，拥有人类可读的名字的进程会更加方便。幸运的是，Process类允许你获取进程的名字，实例如下，
import os
from multiprocessing import Process,current_process
def doubler(number):
result = number * 2
proc_name = current_process().name
print("{0} double to {1} by process id:{2}\n".format(number,result,proc_name))
if __name__ == "__main__":
numbers = [5,10,15,20,25]
procs = []
proc = Process(target = doubler, args = (5,))
for index,number in enumerate(numbers):
proc = Process(target = doubler,args = (number,))
procs.append(proc)
proc.start()
proc = Process(target = doubler,name = "Test",args = (2,))
proc.start()
procs.append(proc)
proc = Process(target = doubler,args = (3,))
proc.start()
procs.append(proc)
for proc in procs:
proc.join()
在这个例子中，我们另外引入了current_process。current_process与threading模块中的current_thread很相似。我们用它获取当前正在调用函数的进程的名字。你将会注意到，前面5个进程，我们没有设置名字。对于第6个进程，我们设置该进程名字为"Test"，让我们看一下输出，
5 double to 10 by process id:Process-2
10 double to 20 by process id:Process-3
15 double to 30 by process id:Process-4
25 double to 50 by process id:Process-6
2 double to 4 by process id:Test
20 double to 40 by process id:Process-5
3 double to 6 by process id:Process-8
输出显示了multiprocessing模块给每个进程赋予一个编号作为它的名字的一部分。当我们指定一个线程的名字时，数字就不会再加入到名字中。由于第6个进程本来的编号是7，但是由于它已经指定进程名字，因此对于最后一个线程，跳过数字7，编号就为8。
2.2 进程锁
multiprocessing模块支持进程锁的方式与threading模块支持线程锁的方式相同。你所需要做的就是引入Lock，获取它，处理任务，然后释放。实例如下，
from multiprocessing import Process,Lock
def printer(item,lock):
lock.acquire()
try:
print(item)
finally:
lock.release()
if __name__ == "__main__":
lock = Lock()
items = ['tango','foxtrot',10]
for item in items:
p = Process(target = printer,args = (item,lock))
p.start()
在这里，我们首先创建一个简单的将输入打印出来的函数。为了阻止进程之间的互相干扰，我们使用了一个Lock对象。这段代码遍历列表中的三个元素，给每个元素都创建一个进程。每个进程在调用函数时，传入一个列表中的元素。由于我们使用了进程锁，下一个进程将会等待线程锁释放后才能执行。
2.3 日志
进程中输出日志与线程中输出日志有所不同。原因就是Python的logging库没有使用进程共享锁，所以你可能会得到多个进程混合的日志信息。让我们尝试在前面的例子中加入日志模块，如下所示，
import logging
import multiprocessing
from multiprocessing import Process,Lock
def printer(item,lock):
lock.acquire()
try:
print(item)
finally:
lock.release()
if __name__ == "__main__":
lock = Lock()
items = ['tango','foxtrot',10]
multiprocessing.log_to_stderr()
logger = multiprocessing.get_logger()
logger.setLevel(logging.INFO)
for item in items:
p = Process(target = printer,args = (item,lock))
p.start()
最简单的方式就是将日志输出到标准错误流上。我们调用log_to_stderr()函数来完成。然后我们调用get_logger方法获取一个logger对象，并且设置日志等级为INFO。剩余的代码和上面的例子是一样的。这里，我并没有调用join()方法。父线程会默认调用join()方法。
当你运行这段代码时，你将会看到与以下结果相似的信息，
tango
[INFO/Process-1] child process calling self.run()
foxtrot
[INFO/Process-1] process shutting down
[INFO/Process-1] process exiting with exitcode 0
[INFO/Process-2] child process calling self.run()
[INFO/Process-2] process shutting down
[INFO/MainProcess] process shutting down
[INFO/Process-2] process exiting with exitcode 0
[INFO/MainProcess] calling join() for process Process-2
[INFO/MainProcess] calling join() for process Process-1
[INFO/MainProcess] calling join() for process Process-3
[INFO/Process-3] child process calling self.run()
10
[INFO/Process-3] process shutting down
[INFO/Process-3] process exiting with exitcode 0
2.4 Pool
Pool类用于表示一个工作进程池。它允许你卸载工作进程中的任务。让我们看一个简单的实例，
from multiprocessing import Pool
def doubler(number):
return number * 2
if __name__ == "__main__":
numbers = [5,10,20]
pool = Pool(processes = 3)
print(pool.map(doubler,numbers))
这里，我们首先创建一个Pool实例，并且告诉它创建三个工作进程。然后我们使用map方法，将函数和可迭代对象与每个进程一一建立对映。最后，我们将结果打印出来，也就是 [10,20,40] 。
你也可以通过使用apply_async方法来获取进程池中进程的结果。
from multiprocessing import Pool
def doubler(number):
return number * 2
if __name__ == "__main__":
numbers = [5,10,20]
pool = Pool(processes = 3)
result = pool.apply_async(doubler,(25,))
print(result.get(timeout = 1))
get函数允许我们直接访问进程的结果。你将会注意到我们设置了超时，以防当我们在调用函数时出现意外。我们并不希望程序莫名奇妙地被阻塞了。
2.5 进程通信
multiprocessing模块主要有两种方法来实现进程间通信，分别是队列和管道。队列实现方式是线程和进程安全。让我们看一看基于队列实现的进程间通信的实例，
from multiprocessing import Process,Queue
sentine1 = -1
def creator(data,q):
print("Creating data putting it on the queue")
for item in data:
q.put(item)
def my_consumer(q):
while True:
data = q.get()
print("data found to be processed:{}".format(data))
processed = data * 2
print(processed)
if data is sentine1:
break
if __name__ == "__main__":
q = Queue()
data = [5,10,13,-1]
process_one = Process(target = creator,args = (data,q))
process_two = Process(target = my_consumer, args = (q,))
process_one.start()
process_two.start()
q.close()
q.join_thread()
process_one.join()
process_two.join()
这里，我们首先引入Queue和Process。然后我们创建两个函数，第一个函数生产数据，并将数据添加到队列；第二个函数消费数据并处理它。添加数据到队列通过队列的put()方法实现，从队列中获取数据是通过队列的get()方法实现。代码块中的最后一部分是创建队列对象，两个进程并且启动进程。你将会注意到我们实在进程上调用join()方法，而不是在队列上。
2.6 总结
我们在本文中讲解了很多技术点。你已经学习了如何在常规函数上使用multiprocessing模块，使用队列进行进程间通信，对进程命名等等。在本文中，Python文档中仍然还有很多知识没有涉及到，一定要继续钻研。在此期间，你已经了解到如何通过Python利用你手中计算机的处理能力。
