Unterschied zwischen Sellerie erhalten und kommt

Question

Gibt es einen Unterschied zwischen:

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

Und:

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

Sellerie Dokument verwendet beiden Beispiele, und ich sehe keinen Unterschied.

Answer 1

Der Unterschied ist der Unterschied zwischen Gruppen und Akkorden. Die Frage ist, ob Sie das Ergebnis aller Ihrer Aufgaben haben wollen oder ob Sie eine Aufgabe haben möchten, die etwas mit den Ergebnissen macht.

Gruppen werden verwendet, um mehrere Aufgaben zu starten und dann die Ergebnisse in der Reihenfolge beizutreten, in der sie aufgerufen wurden.

>>> 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] 

Akkorde sind, wenn Sie eine Aufgabe wollen, dass alle angegebenen Aufgaben erledigt ausführt, nachdem werden.

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

Sie können mehr über diese erfahren hier: http://ask.github.io/celery/userguide/tasksets.html

Answer 2

Kurze Antwort

Während die get und join Methoden für eine group die gleichen Ergebnisse zurückgeben soll, implementiert get einige Caching und wird wahrscheinlich Je nachdem, welches Backend Sie verwenden, ist es effizienter. Sofern Sie nicht unbedingt join für einen Randfall verwenden müssen, sollten Sie get verwenden.

Lange Antwort

Hier ist die Quelle für die get Methode der ResultSet Klasse Sellerie, die die GroupResult-Klasse erweitert.

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

Das erste, was wir sehen ist, dass die docstring uns auf der join Methode für die Dokumentation suchen erzählt. Das ist ein Indiz dafür, dass die Methoden sehr ähnlich sind.

Mit Blick auf den Körper der get Methode können wir sehen, dass es zunächst nach einem zwischengespeicherten Wert überprüft und gibt zurück, wenn es festgelegt ist. Wenn kein zwischengespeicherter Wert gefunden wird, ruft get entweder die Methode join oder join_native auf, abhängig davon, ob das Back-End native Joins unterstützt. Wenn Sie das Format dieser return Aussage ein wenig verwirrend finden, das ist im Wesentlichen das Gleiche:

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) 

Die docstring für die join Methode hat dies zu sagen.

Dies kann eine kostspielige Operation für Ergebnisspeicher-Backends sein, die auf Abfrage (z. B. Datenbank) zurückgreifen müssen. Sie sollten in Betracht ziehen, join_native zu verwenden, wenn Ihr Backend dies unterstützt.

So Sie sollten anrufen join_native statt join wenn Ihr Backend unterstützt wird. Aber warum sollte man sich auf den einen oder den anderen zurückrufen, wenn get diese Logik für Sie zusammenfasst? Verwenden Sie stattdessen get.