芹菜获取和加入之间的区别

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

简答

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

长答案

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

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,
    )

我们看到的第一件事是文档字符串告诉我们查看文档的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方法的文档字符串有这样的说法。

对于必须 诉诸轮询(例如，数据库(。您应该考虑使用 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