में मल्टीप्रोसेसिंग के साथ बाल प्रक्रियाओं को सही तरीके से कैसे समाप्त करें मेरे पास कुछ कॉलबैक फ़ंक्शन हैं और मैं एकाधिक प्रक्रियाओं के रूप में लॉन्च करना चाहता हूं और उन्हें सभी को मूल प्रक्रिया से सिग्नल के माध्यम से समाप्त करना है।पाइथन
ऐसा करने का मेरा वर्तमान तरीका multiprocessing.Value के साथ साझा c_bool बना रहा है और इसे True पर सेट कर रहा है, फिर इसे बनाए जाने पर मेरी सभी प्रक्रियाओं में इसे वितरित कर रहा है।
while myC_bool: ...keep running...
मैं तो बस bool False करने के लिए अपने माता-पिता की प्रक्रिया और सभी चाइल्ड प्रक्रियाओं से स्विच उनके अंतिम पाश और बाहर निकलने पूरा हो जाएगा कर सकते हैं: मेरी प्रक्रियाओं सब थोड़ी देर के पाश तो जैसे साझा bool का उपयोग कर चलाते हैं।
मुझे कई लोगों ने बताया है, और दस्तावेज़ों में पढ़ा है कि मल्टीप्रोसेसिंग का उपयोग करते समय साझा स्मृति का उपयोग करने से बचने की कोशिश करनी चाहिए। मुझे यह बताने का सबसे अच्छा तरीका बताया गया था कि प्रक्रिया को डिमननाइज़ करना है, इसे एक कस्टम सिग्नल हैंडलर दें और इसे एक सिग्ंट/सिगरेट/आदि भेजें ...
मेरा प्रश्न है, विशेष रूप से बूल का उपयोग करके बूल का उपयोग करना लूप जीवित है और केवल मेरे माता-पिता की प्रक्रिया से इसका मूल्य बदलता है, और इसे कई बाल प्रक्रियाओं से पढ़ता है ताकि मेरे सभी बच्चे की प्रक्रियाएं जल्दी और सुरक्षित रूप से समाप्त हो सकें? मुझे लगता है कि उन सभी बच्चों के लिए सिग्नेट भेजने की तुलना में, सभी बच्चों के लिए एक साझा बूल को देखने के लिए कम ओवरहेड है।
क्या डिमोनाइजिंग बेहतर समाधान होगा? यदि ऐसा है तो मुझे समझने में कुछ मदद चाहिए क्यों।
आपकी प्रतिक्रिया के लिए धन्यवाद, मैं जिस विधि का उपयोग कर रहा हूं उस पर आलोचना की सराहना करता हूं। मैंने इस तथ्य को अनदेखा कर दिया था कि भले ही वे विभिन्न प्रक्रियाओं में हैं, फिर भी उन्हें मूल्य देखने के लिए एक लॉक प्राप्त करना होगा। क्या मैं साझा मूल्यों से बचने का एक कारण सोचने में सही हूं क्योंकि यह प्रक्रियाओं को अधिक थ्रेड-जैसी बनाता है, कई प्रक्रियाओं का उपयोग करने के कुछ फायदों में बाधा डालता है? – LISTERINE
@LISTERINE: मैंने कभी इस तरह से सोचा नहीं, लेकिन हाँ, यह देखने का एक अच्छा तरीका है। धागे के लिए बड़ा नुकसान यह है कि साझा (उत्परिवर्तनीय) मान संदेश पास होने के कारण तर्क के लिए कठिन होते हैं, और समवर्ती प्रोग्रामिंग दौड़ के बारे में सोचने के बिना पर्याप्त कठिन है। सीपीथन-विशिष्ट नुकसान यह है कि जीआईएल का मतलब है कि थ्रेडेड कोड स्वाभाविक रूप से अधिक सिंक्रनाइज़ होता है और समानांतर के बजाय लगभग धारावाहिक समाप्त होता है। स्पष्ट साझा मूल्य अंतर्निहित साझाकरण के रूप में उतना बुरा नहीं है, और एक मूल्य के चारों ओर एक लॉक जीआईएल जितना बुरा नहीं है, लेकिन वे थ्रेडिंग के नुकसान की ओर कदम उठा रहे हैं। – abarnert
@LISTERINE: ... कहा जा रहा है, यह उल्लेखनीय है कि ये विशेषताएं किसी कारण से मौजूद हैं: कभी-कभी मल्टीप्रोसेसिंग से शुरू करना और थ्रेडिंग की तरफ एक कदम उठाना (ए) थ्रेडिंग से शुरू करना और इससे दूर जाने की कोशिश करना, या (बी) अपने पूरे एल्गोरिदम को पुनर्गठित करना ताकि इसे साझा किए बिना कोड किया जा सके। – abarnert