Differenza tra sedano ottenere e unirsi

Question

C'è qualche differenza tra:

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

E:

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

documento sedano utilizza entrambi gli esempi e non vedo alcuna differenza.

Answer 1

La differenza è la differenza tra i gruppi e gli accordi. La domanda è se si desidera il risultato di tutte le attività o se si desidera un'attività che faccia qualcosa con i risultati.

I gruppi vengono utilizzati per avviare diverse attività e quindi unire i risultati nell'ordine in cui sono stati richiamati.

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

Chords sono quando si desidera un compito che viene eseguito dopo tutti i compiti specificati sono fatto.

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

Si può imparare di più su questi qui: http://ask.github.io/celery/userguide/tasksets.html

Answer 2

Risposta breve

Mentre i get e join metodi per un group dovrebbero restituire gli stessi risultati, get implementa alcune caching e probabilmente essere più efficiente a seconda del backend che stai utilizzando. A meno che tu non abbia davvero bisogno di usare join per un caso limite, devi usare get.

Risposta lunga

Ecco l'origine per il metodo della classe di sedano ResultSetget cui la classe GroupResult estende.

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

La prima cosa che vediamo è che il docstring ci dice di guardare il metodo join per la documentazione. A prima vista, questa è un'indicazione che i metodi sono molto simili.

Osservando il corpo del metodo get, possiamo vedere che prima controlla un valore memorizzato nella cache e lo restituisce se è impostato. Se non viene trovato alcun valore memorizzato nella cache, get chiamerà il metodo o il metodo join_native a seconda che il backend supporti i join nativi. Se trovate il formato che return dichiarazione un po 'di confusione, questo è essenzialmente la stessa cosa:

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) 

Il docstring per il metodo join ha questo da dire.

Questa operazione può risultare costosa per i backend di archivio dei risultati che devono corrispondere a ricorso al polling (ad es. Database). Dovresti considerare l'utilizzo di join_native se il tuo back-end lo supporta.

Così si dovrebbe essere chiamata join_native invece di join se il back-end lo supporta. Ma perché preoccuparsi di chiamare condizionatamente l'uno o l'altro se get avvolge questa logica per te? Basta usare get invece.