之前文章中介绍了python中multiprocessing模块中自带的进程池Pool，并对进程池中的数据结构和各个线程之间的合作关系进行了简单分析，这节来看下客户端如何对向进程池分配任务，并获取结果的。
我们知道，当进程池中任务队列非空时，才会触发worker进程去工作，那么如何向进程池中的任务队列中添加任务呢，进程池类有两组关键方法来创建任务，分别是apply/apply_async和map/map_async，实际上进程池类的apply和map方法与python内建的两个同名方法类似，apply_async和map_async分别为它们的非阻塞版本。
首先来看apply_async方法，源码如下：
def apply_async(self, func, args=(), kwds={}, callback=None): assert self._state == RUN result = ApplyResult(self._cache, callback) self._taskqueue.put(([(result._job, None, func, args, kwds)], None)) return result
func表示执行此任务的方法
args、kwds分别表func的位置参数和关键字参数
callback表示一个单参数的方法，当有结果返回时，callback方法会被调用，参数即为任务执行后的结果
每调用一次apply_result方法，实际上就向_taskqueue中添加了一条任务，注意这里采用了非阻塞（异步）的调用方式，即apply_async方法中新建的任务只是被添加到任务队列中，还并未执行，不需要等待，直接返回创建的ApplyResult对象，注意在创建ApplyResult对象时，将它放入进程池的缓存_cache中。
任务队列中有了新创建的任务，那么根据上节分析的处理流程，进程池的_task_handler线程，将任务从taskqueue中获取出来，放入_inqueue中，触发worker进程根据args和kwds调用func，运行结束后，将结果放入_outqueue，再由进程池中的_handle_results线程，将运行结果从_outqueue中取出，并找到_cache缓存中的ApplyResult对象，_set其运行结果，等待调用端获取。
apply_async方法既然是异步的，那么它如何知道任务结束，并获取结果呢？这里需要了解ApplyResult类中的两个主要方法：
def get(self, timeout=None): self.wait(timeout) if not self._ready: raise TimeoutError if self._success: return self._value else: raise self._value def _set(self, i, obj): self._success, self._value = obj if self._callback and self._success: self._callback(self._value) self._cond.acquire() try: self._ready = True self._cond.notify() finally: self._cond.release() del self._cache[self._job]
从这两个方法名可以看出，get方法是提供给客户端获取worker进程运行结果的，而运行的结果是通过_handle_result线程调用_set方法，存放在ApplyResult对象中。
_set方法将运行结果保存在ApplyResult._value中，唤醒阻塞在条件变量上的get方法。客户端通过调用get方法，返回运行结果。
apply方法是以阻塞的方式运行获取进程结果，它的实现很简单，同样是调用apply_async，只不过不返回ApplyResult，而是直接返回worker进程运行的结果：
def apply(self, func, args=(), kwds={}):
assert self._state == RUN
return self.apply_async(func, args, kwds).get()
以上的apply/apply_async方法，每次只能向进程池分配一个任务，那如果想一次分配多个任务到进程池中，可以使用map/map_async方法。首先来看下map_async方法是如何定义的：
def map_async(self, func, iterable, chunksize=None, callback=None):
assert self._state == RUN
if not hasattr(iterable, '__len__'):
iterable = list(iterable)
if chunksize is None:
chunksize, extra = divmod(len(iterable), len(self._pool) * 4)
if extra:
chunksize += 1
if len(iterable) == 0:
chunksize = 0
task_batches = Pool._get_tasks(func, iterable, chunksize)
result = MapResult(self._cache, chunksize, len(iterable), callback)
self._taskqueue.put((((result._job, i, mapstar, (x,), {})
for i, x in enumerate(task_batches)), None))
return result
func表示执行此任务的方法
iterable表示任务参数序列
chunksize表示将iterable序列按每组chunksize的大小进行分割，每个分割后的序列提交给进程池中的一个任务进行处理
callback表示一个单参数的方法，当有结果返回时，callback方法会被调用，参数即为任务执行后的结果
从源码可以看出，map_async要比apply_async复杂，首先它会根据chunksize对任务参数序列进行分组，chunksize表示每组中的任务个数，当默认chunksize=None时，根据任务参数序列和进程池中进程数计算分组数：chunk, extra = divmod(len(iterable), len(self._pool) * 4)。假设进程池中进程数为len(self._pool)=4，任务参数序列iterable=range(123)，那么chunk=7, extra=11，向下执行，得出chunksize=8，表示将任务参数序列分为8组。任务实际分组：
task_batches = Pool._get_tasks(func, iterable, chunksize)
def _get_tasks(func, it, size):
it = iter(it)
while 1:
x = tuple(itertools.islice(it, size))
if not x:
return
yield (func, x)
这里使用yield将_get_tasks方法编译成生成器。实际上对于range(123)这样的序列，按照chunksize=8进行分组后，一共16组每组的元素如下：
(func, (0, 1, 2, 3, 4, 5, 6, 7))
(func, (8, 9, 10, 11, 12, 13, 14, 15))
(func, (16, 17, 18, 19, 20, 21, 22, 23))
...
(func, (112, 113, 114, 115, 116, 117, 118, 119))
(func, (120, 121, 122))
分组之后，这里定义了一个MapResult对象：result = MapResult(self._cache, chunksize, len(iterable), callback)它继承自AppyResult类，同样提供get和_set方法接口。将分组后的任务放入任务队列中，然后就返回刚刚创建的result对象。
self._taskqueue.put((((result._job, i, mapstar, (x,), {}) for i, x in enumerate(task_batches)), None)) 以任务参数序列=range(123)为例，实际上这里向任务队列中put了一个16组元组元素的集合，元组依次为： (result._job, 0, mapstar, ((func, (0, 1, 2, 3, 4, 5, 6, 7)),), {}, None) (result._job, 1, mapstar, ((func, (8, 9, 10, 11, 12, 13, 14, 15)),), {}, None) …… (result._job, 15, mapstar, ((func, (120, 121, 122）),), {}, None)
注意每一个元组中的 i，它表示当前元组在整个任务元组集合中的位置，通过它，_handle_result线程才能将worker进程运行的结果，以正确的顺序填入到MapResult对象中。
注意这里只调用了一次put方法，将16组元组作为一个整体序列放入任务队列，那么这个任务是否_task_handler线程是否也会像apply_async方法一样，将整个任务序列传递给_inqueue，这样就会导致进程池中的只有一个worker进程获取到任务序列，而并非起到多进程的处理方式。我们来看下_task_handler线程是怎样处理的：
def _handle_tasks(taskqueue, put, outqueue, pool, cache):
thread = threading.current_thread()
for taskseq, set_length in iter(taskqueue.get, None):
i = -1
for i, task in enumerate(taskseq):
if thread._state:
debug('task handler found thread._state != RUN')
break
try:
put(task)
except Exception as e:
job, ind = task[:2]
try:
cache[job]._set(ind, (False, e))
except KeyError:
pass
else:
if set_length:
debug('doing set_length()')
set_length(i+1)
continue
break
else:
debug('task handler got sentinel')
注意到语句 for i, task in enumerate(taskseq)，原来_task_handler线程在通过taskqueue获取到任务序列后，并不是直接放入_inqueue中的，而是将序列中任务按照之前分好的组，依次放入_inqueue中的，而循环中的task即上述的每个任务元组：(result._job, 0, mapstar, ((func, (0, 1, 2, 3, 4, 5, 6, 7)),), {}, None)。接着触发worker进程。worker进程获取出每组任务，进行任务的处理：
job, i, func, args, kwds = task try:
result = (True, func(*args, **kwds)) except Exception, e:
result = (False, e) try:
put((job, i, result))
except Exception as e:
wrapped = MaybeEncodingError(e, result[1])
debug("Possible encoding error while sending result: %s" % (
wrapped))
put((job, i, (False, wrapped)))
根据之前放入_inqueue的顺序对应关系：
(result._job, 0, mapstar, ((func, (0, 1, 2, 3, 4, 5, 6, 7)),), {}, None)
job, i, func, args, kwds = task
可以看出，元组中 mapstar 表示这里的回调函数func，((func, (0, 1, 2, 3, 4, 5, 6, 7)),)和{}分别表示args和kwds参数。
执行result = (True, func(*args, **kwds))
再来看下mapstar是如何定义的：
def mapstar(args):
return map(*args)
这里mapstar表示回调函数func，它的定义只有一个参数，而在worker进程执行回调时，使用的是func(*args, **kwds)语句，这里多一个参数能够正确执行吗？答案时肯定的，在调用mapstar时，如果kwds为空字典，那么传入第二个参数不会影响函数的调用，而一个无参函数func_with_none_params，在调用时使用func_with_none_params(*(), **{})也是没有问题的，python会自动忽视传入的两个空参数。
看到这里，我们明白了，实际上对任务参数分组后，每一组的任务是通过内建的map方法来进行调用的。
运行之后调用put(job, i, result)将结果放入_outqueue中，_handle_result线程会从_outqueue中将结果取出，并找到_cache缓存中的MapResult对象，_set其运行结果
现在来我们来总结下，进程池的map_async方法是如何运行的，我们将range(123)这个任务序列，将它传入map_async方法，假设不指定chunksize，并且cpu为四核，那么方法内部会分为16个组（0~14组每组8个元素，最后一组3个元素）。将分组后的任务放入任务队列，一共16组，那么每个进程需要运行4次来处理，每次通过内建的map方法，顺序将组中8个任务执行，再将结果放入_outqueue，找到_cache缓存中的MapResult对象，_set其运行结果，等待客户端获取。使用map_async方法会调用多个worker进程处理任务，每个worler进程运行结束，会将结果传入_outqueue，再有_handle_result线程将结果写入MapResult对象，那如何保证结果序列的顺序与调用map_async时传入的任务参数序列一致呢，我们来看看MapResult的构造函数和_set方法的实现。
def __init__(self, cache, chunksize, length, callback):
ApplyResult.__init__(self, cache, callback)
self._success = True
self._value = [None] * length
self._chunksize = chunksize
if chunksize <= 0:
self._number_left = 0
self._ready = True
del cache[self._job]
else:
self._number_left = length//chunksize + bool(length % chunksize)
def _set(self, i, success_result):
success, result = success_result
if success:
self._value[i*self._chunksize:(i+1)*self._chunksize] = result
self._number_left -= 1
if self._number_left == 0:
if self._callback:
self._callback(self._value)
del self._cache[self._job]
self._cond.acquire()
try:
self._ready = True
self._cond.notify()
finally:
self._cond.release()
else:
self._success = False
self._value = result
del self._cache[self._job]
self._cond.acquire()
try:
self._ready = True
self._cond.notify()
finally:
self._cond.release()
MapResult类中，_value保存map_async的运行结果，初始化时为一个元素为None的list，list的长度与任务参数序列的长度相同，_chunksize表示将任务分组后，每组有多少个任务，_number_left表示整个任务序列被分为多少个组。_handle_result线程会通过_set方法将worker进程的运行结果保存到_value中，那么如何将worker进程运行的结果填入到_value中正确的位置呢，还记得在map_async在向task_queue填入任务时，每组中的 i吗，i表示的就是当前任务组的组号，_set方法会根据当前任务的组号即参数 i，并且递减_number_left，当_number_left递减为0时，表示任务参数序列中的所有任务都已被woker进程处理，_value全部被计算出，唤醒阻塞在get方法上的条件变量，是客户端可以获取运行结果。
map函数为map_async的阻塞版本，它在map_async的基础上，调用get方法，直接阻塞到结果全部返回：
def map(self, func, iterable, chunksize=None):
assert self._state == RUN
return self.map_async(func, iterable, chunksize).get()
这节我们主要分析了两组向进程池分配任务的接口：apply/apply_async和map/map_async。apply方法每次处理一个任务，不同任务的执行方法（回调函数）、参数可以不同，而map方法每次可以处理一个任务序列，每个任务的执行方法相同。
未完待续……
