Question

我试图了解使用多处理池的apply_sync方法时幕后发生的一些事情。

谁运行回调方法？它是调用apply_async的主要过程吗？

让我说我发送了一大堆带回调的apply_async命令，然后继续我的程序。当apply_async开始完成时，我的程序仍在执行操作。回调如何运行我的主要过程＆＃34;虽然主要流程仍然忙于脚本？

以下是一个例子。

import multiprocessing
import time

def callback(x):
    print '{} running callback with arg {}'.format(multiprocessing.current_process().name, x)

def func(x):
    print '{} running func with arg {}'.format(multiprocessing.current_process().name, x)
    return x

pool = multiprocessing.Pool()

args = range(20)

for a in args:
    pool.apply_async(func, (a,), callback=callback)

print '{} going to sleep for a minute'.format(multiprocessing.current_process().name)

t0 = time.time()
while time.time() - t0 < 60:
    pass

print 'Finished with the script'

输出类似于

使用arg 0运行func的PoolWorker-1

使用arg 1运行func的PoolWorker-2

使用arg 2运行func的PoolWorker-3

MainProcess进入休眠状态＆lt; - 主进程正忙

使用arg 3运行func的PoolWorker-4

使用arg 4运行func的PoolWorker-1

使用arg 5运行func的PoolWorker-2

使用arg 6运行func的PoolWorker-3

使用arg 7运行func的PoolWorker-4

MainProcess运行带有arg 0 的回调＆lt; - 主进程在while循环中运行回调!!

MainProcess使用arg 1运行回调

使用arg 2运行回调的MainProcess

使用arg 3运行回调的MainProcess

使用arg 4运行回调的MainProcess

使用arg 8运行func的PoolWorker-1

...

完成脚本

当MainProcess在while循环的中间运行回调时，它是如何运行的？

有关multiprocessing.Pool文档中回调的声明似乎是一个提示，但我不理解。

apply_async（func [，args [，kwds [，callback]]]）

apply（）方法的一种变体，它返回一个结果对象。

如果指定了回调，那么它应该是一个可调用的，它接受一个参数。当结果变为就绪时，将对其应用回调（除非调用失败）。回调应该立即完成，否则处理结果的线程将被阻止。

Answer 1

文档中确实有一个暗示：

回调应该立即完成，因为否则线程哪个处理结果将被阻止。

回调在主进程中处理，但它们在自己的单独线程中运行。当您创建Pool时，它实际上会在内部创建一些Thread个对象：

class Pool(object):
    Process = Process

    def __init__(self, processes=None, initializer=None, initargs=(),
                 maxtasksperchild=None):
        self._setup_queues()
        self._taskqueue = Queue.Queue()
        self._cache = {}
        ... # stuff we don't care about
        self._worker_handler = threading.Thread(
            target=Pool._handle_workers,
            args=(self, )
            )
        self._worker_handler.daemon = True
        self._worker_handler._state = RUN 
        self._worker_handler.start()

        self._task_handler = threading.Thread(
            target=Pool._handle_tasks,
            args=(self._taskqueue, self._quick_put, self._outqueue,
                  self._pool, self._cache)
            )
        self._task_handler.daemon = True
        self._task_handler._state = RUN 
        self._task_handler.start()

        self._result_handler = threading.Thread(
            target=Pool._handle_results,
            args=(self._outqueue, self._quick_get, self._cache)
            )
        self._result_handler.daemon = True
        self._result_handler._state = RUN
        self._result_handler.start()

我们感兴趣的主题是_result_handler;我们很快就会明白为什么。

当您运行apply_async时，切换齿轮一秒钟，它会在内部创建一个ApplyResult对象来管理从孩子那里获取结果：

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

class ApplyResult(object):

    def __init__(self, cache, callback):
        self._cond = threading.Condition(threading.Lock())
        self._job = job_counter.next()
        self._cache = cache
        self._ready = False
        self._callback = callback
        cache[self._job] = self


    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]

正如您所看到的，假设任务成功，_set方法最终会实际执行传入的callback。另请注意，它会在cache末尾添加到全局__init__字典中。

现在，回到_result_handler线程对象。该对象调用_handle_results函数，如下所示：

    while 1:
        try:
            task = get()
        except (IOError, EOFError):
            debug('result handler got EOFError/IOError -- exiting')
            return

        if thread._state:
            assert thread._state == TERMINATE
            debug('result handler found thread._state=TERMINATE')
            break

        if task is None:
            debug('result handler got sentinel')
            break

        job, i, obj = task
        try:
            cache[job]._set(i, obj)  # Here is _set (and therefore our callback) being called!
        except KeyError:
            pass

        # More stuff

这是一个循环，它只是从子队列中取出结果，在cache中找到它的条目，并调用_set来执行我们的回调。即使你处于循环中它也可以运行，因为它没有在主线程中运行。

谁在使用多处理池的apply_async方法时运行回调？

1 个答案: