Django: पृष्ठभूमि धागे में एक प्रक्रिया शुरू करें?

Question

मैं Django में पृष्ठभूमि थ्रेड में प्रक्रिया को चलाने के तरीके को करने का प्रयास कर रहा हूं। मैं Django और धागे दोनों के लिए नया हूँ, इसलिए अगर मैं शब्दावली का गलत उपयोग कर रहा हूं तो कृपया मेरे साथ भालू।

यहां मेरे पास कोड है। मूल रूप से फ़ंक्शन ट्रिगर होने पर मुझे start_processing प्रारंभ करना होगा। हालांकि start_processing ऐसा फ़ंक्शन है जो आसानी से कुछ मिनट ले सकता है या असफल हो सकता है (यह बाहरी सेवा पर निर्भर है जिस पर मेरा कोई नियंत्रण नहीं है), और मैं नहीं चाहता कि उपयोगकर्ता को सफलतापूर्वक पूरा करने के लिए इसके लिए इंतजार करना पड़े दृश्य प्रस्तुत किया जाता है। ('सफल' जहाँ तक वे चिंतित हैं start_processing का परिणाम पर निर्भर नहीं है;। मैं केवल एक ही व्यक्ति है जो चिंता करने की जरूरत है अगर यह विफल कर रहा हूँ)

def success(request, filepath): 
    start_processing(filepath) 
    return render_to_response('success.html', context_instance = RequestContext(request)) 

Googling से मेरे द्वारा की गई, ज्यादातर लोग सुझाव देते हैं कि Django में पृष्ठभूमि धागे का उपयोग नहीं किया जाता है, और इसके बजाय एक क्रॉन नौकरी अधिक उपयुक्त है। लेकिन क्रॉन नौकरी चलाने तक इंतजार करने के बजाए, उपयोगकर्ता को सफलता समारोह में जल्द ही start_processing पसंद आएगा। क्या इसे करने का कोई तरीका है?

Answer 1

मुझे यकीन नहीं है कि इसके लिए आपको एक धागा चाहिए। ऐसा लगता है कि आप बस एक प्रक्रिया को दूर करना चाहते हैं, इसलिए subprocess मॉड्यूल देखें।

Answer 2

IIUC, समस्या यह है कि वेब सर्वर प्रक्रिया अतिरिक्त लंबे समय से चल धागे अंडे सर्वर प्रक्रियाओं मांग ऊपर जाना के रूप में पसंद कर सकते हैं नहीं है, यह मार सकते/और नीचे, वगैरह वगैरह

आप शायद के बेहतर कर रहे है इस प्रकार की प्रसंस्करण के लिए बाहरी सेवा प्रक्रिया से संचार करके, इसे वेबसर्वर की wsgi/fastcgi प्रक्रिया में एम्बेड करने के बजाय।

यदि आप जिस चीज को भेज रहे हैं वह फ़ाइलपैथ है, तो उसे उस सेवा ऐप को लिखना बहुत आसान होना चाहिए।

Answer 3

यदि आपको वास्तव में एक त्वरित हैक की आवश्यकता है, तो बस subprocess का उपयोग कर प्रक्रिया शुरू करें।

लेकिन मैं एक प्रक्रिया को उत्पन्न करने (या यहां तक ​​कि एक धागा), खासकर अगर अपने वेब साइट सार्वजनिक है नहीं की सिफारिश करेंगे: उच्च लोड के मामले में (जो "प्राकृतिक" हो सकता है या एक छोटी सी DoS हमले के परिणाम) , आप कई प्रक्रियाओं या धागे को जन्म देंगे, जो आपके सभी सिस्टम संसाधनों का उपयोग करके और आपके सर्वर को मारने का अंत होगा।

मैं बजाय एक नौकरी सर्वर का उपयोग कर की सिफारिश करेंगे: मैं (बैकएंड के रूप में Redis साथ) का उपयोग Celery, यह बहुत आसान है और सिर्फ अच्छा काम करता है। आप कई अन्य नौकरी सर्वर देख सकते हैं, जैसे कि रब्बीएमक्यू या गियरमैन। आपके मामले में, एक जॉब सर्वर ओवरकिल हो सकता है: आप बस रेडिस चला सकते हैं और इसे हल्के वजन संदेश सर्वर के रूप में उपयोग कर सकते हैं। यह कैसे करें an example है।

चीयर्स

Answer 4

मामले किसी में वास्तव में, एक और धागा

def background_process(): 
    import time 
    print("process started") 
    time.sleep(100) 
    print("process finished") 

def index(request): 
    import threading 
    t = threading.Thread(target=background_process, args=(), kwargs={}) 
    t.setDaemon(True) 
    t.start() 
    return HttpResponse("main thread content") 

यह पहली प्रतिक्रिया वापस आ जाएगी चलाने के लिए फिर प्रिंट चाहता है "प्रक्रिया समाप्त" सांत्वना देने। तो उपयोगकर्ता को किसी देरी का सामना नहीं करना पड़ेगा।

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

आपको एक बड़ी परियोजना में धागे का उपयोग करने की भी आवश्यकता हो सकती है। क्योंकि आपके सभी सर्वरों में सेलेरी चलाना एक अच्छा विचार नहीं है।फिर प्रत्येक सर्वर में एक अलग प्रक्रिया चलाने का कोई तरीका नहीं होगा। इस मामले को संभालने के लिए आपको धागे की आवश्यकता हो सकती है। फाइल सिस्टम ऑपरेशंस एक उदाहरण हो सकता है। हालांकि यह बहुत संभावना नहीं है और लंबे समय तक चलने वाली प्रक्रियाओं के साथ सेलेरी का उपयोग करना अभी भी बेहतर है।

बुद्धिमानी से उपयोग करें।