芹菜和加入之间的区别

Question

之间有什么区别:

 r = group(some_task.s(i) for i in range(10)).apply_async()
 result = r.join()

和:

 r = group(some_task.s(i) for i in range(10))()
 result = r.get()

芹菜文档使用两个示例,我没有看到任何差异.

Answer 1

简短的回答

虽然a get和的join方法group应该返回相同的结果,但get实现一些缓存,并且可能会更高效,具体取决于您正在使用的后端.除非你真的需要join用于某些边缘情况,否则你应该使用get.

答案很长

这是该类扩展get的芹菜ResultSet类方法的来源GroupResult.

def get(self, timeout=None, propagate=True, interval=0.5,
        callback=None, no_ack=True, on_message=None):
    """See :meth:`join`
    This is here for API compatibility with :class:`AsyncResult`,
    in addition it uses :meth:`join_native` if available for the
    current result backend.
    """
    if self._cache is not None:
        return self._cache
    return (self.join_native if self.supports_native_join else self.join)(
        timeout=timeout, propagate=propagate,
        interval=interval, callback=callback, no_ack=no_ack,
        on_message=on_message,
    )

我们首先看到的是docstring告诉我们要查看join文档的方法.马上,这表明方法非常相似.

查看get方法的主体,我们可以看到它首先检查缓存的值并返回它是否已设置.如果未找到缓存值,get则将调用join该join_native方法或方法,具体取决于后端是否支持本机连接.如果您发现该return语句的格式有点令人困惑,那么这基本上是相同的:

if self.supports_native_join:
    return self.join_native(timeout=timeout,
                            propagate=propagate,
                            interval=interval,
                            callback=callback,
                            no_ack=no_ack,
                            on_message=on_message)
else:
    return self.join(timeout=timeout,
                     propagate=propagate,
                     interval=interval,
                     callback=callback,
                     no_ack=no_ack,
                     on_message=on_message)

该join方法的docstring 就是这样说的.

对于必须求助于轮询的结果存储后端(例如,数据库),这可能是昂贵的操作.join_native如果您的后端支持它,您应该考虑使用 它.

所以你应该打电话join_native而不是join你的后端支持它.但是,为什么要花时间有条不紊地调用一个或另一个如果get为你包装这个逻辑呢？只需使用get.

Answer 2

区别在于组和和弦之间的区别。问题是您是否想要所有任务的结果，或者您是否想要一项对结果执行某些操作的任务。

组用于启动多个任务，然后按照调用顺序连接结果。

>>> job = group([
...             add.subtask((2, 2)),
...             add.subtask((4, 4)),
...             add.subtask((8, 8)),
...             add.subtask((16, 16)),
...             add.subtask((32, 32)),
... ])
>>> result = job.apply_async()
>>> result.join()
[4, 8, 16, 32, 64]

和弦是指您希望在所有指定任务完成后执行的任务。

>>> callback = last_task.subtask()
>>> tasks = [task.subtask(...) ... ]
>>> result = chord(tasks)(callback)
>>> result.get()
<output from last_task which have access to the results from the tasks>

您可以在这里了解更多信息：http://ask.github.io/celery/userguide/tasksets.html