अंतर हो और में शामिल होने

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

अंतर समूहों और chords के बीच अंतर है। सवाल यह है कि यदि आप अपने सभी कार्यों से परिणाम चाहते हैं या यदि आप एक ऐसा कार्य चाहते हैं जो परिणामों के साथ कुछ करता है।

समूह का उपयोग कई कार्यों को शुरू करने के लिए किया जाता है और फिर परिणामों को शामिल करने के क्रम में शामिल होते हैं।

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

Answer 2

लघु जवाब

एक group के लिए get और join तरीकों समान परिणाम चाहिए, get कुछ कैशिंग को लागू करता है और शायद होगा आप जिस बैकएंड का उपयोग कर रहे हैं उसके आधार पर अधिक कुशल बनें। जब तक आपको कुछ किनारे के मामले में join का उपयोग करने की आवश्यकता नहीं है, तो आपको get का उपयोग करना चाहिए।

लांग जवाब

यहाँ अजवाइन के ResultSet वर्ग के get तरीका है जिसके 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 विधि।

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 इस में क्या कहना है: आपको लगता है कि return बयान के प्रारूप में एक छोटे से भ्रामक मिल जाए, यह अनिवार्य रूप से एक ही बात है।

यह परिणाम स्टोर बैकएंड के लिए एक महंगा ऑपरेशन हो सकता है जो मतदान (उदाहरण के लिए, डेटाबेस) का सहारा लेना चाहिए। यदि आपका बैकएंड इसका समर्थन करता है तो आपको join_native का उपयोग करने पर विचार करना चाहिए।

तो तुम join के बजाय join_native बुला जाना चाहिए अपने बैकएंड यह समर्थन करता है तो। लेकिन अगर get आपके लिए इस तर्क को लपेटता है तो सशर्त रूप से एक या दूसरे को कॉल करने का सहारा लेना क्यों परेशान है? इसके बजाए बस get का उपयोग करें।