थ्रेड को पुनरारंभ करते समय इंस्टेंस को फिर से बनाने की आवश्यकता क्यों होती है?

Question

कल्पना कीजिए निम्नलिखित वर्गों:

Class Object(threading.Thread): 
    # some initialisation blabla 
    def run(self): 
     while True: 
      # do something 
      sleep(1) 

class Checker(): 
    def check_if_thread_is_alive(self): 
     o = Object() 
     o.start() 

     while True: 
      if not o.is_alive(): 
       o.start() 

मैं धागा मामले में यह मर चुका है पुनः आरंभ करना चाहते हैं। यह काम नहीं करता है। क्योंकि धागे केवल एक बार शुरू किया जा सकता है। पहला प्रश्न। ऐसा क्यों है?

जहां तक ​​मुझे पता है कि मुझे Object के प्रत्येक उदाहरण को फिर से बनाना है और फिर से धागा शुरू करने के लिए start() पर कॉल करना है। जटिल Object एस के मामले में यह बहुत व्यावहारिक नहीं है। मुझे पुराने Object के वर्तमान मानों को पढ़ना है, एक नया बनाएं और पुराने ऑब्जेक्ट्स के साथ पैरामीटर को नए ऑब्जेक्ट में सेट करें। दूसरा सवाल: क्या यह एक स्मार्ट, आसान तरीके से किया जा सकता है?

Answer 1

थ्रेडिंग का कारण। थ्रेड लागू किया गया है, थ्रेड ऑब्जेक्ट और ऑपरेटिंग सिस्टम के थ्रेड के बीच पत्राचार रखना है। प्रमुख ओएस थ्रेड में पुनरारंभ नहीं किया जा सकता है, लेकिन आप एक और धागा अन्य थ्रेड आईडी के साथ बना सकते हैं।

मनोरंजन एक समस्या है, तो threading.Thread से अपने वर्ग के वारिस की कोई जरूरत नहीं है, बस एक लक्ष्य पैरामीटर ऐसा दिखाई देता है थ्रेड के लिए निर्माता से पारित: धागा सदस्य को नियंत्रित करने के

class MyObj(object): 
    def __init__(self): 
     self.thread = threading.Thread(target=self.run) 
    def run(self): 
     ... 

तो फिर तुम तक पहुंच सकते हैं थ्रेड निष्पादन, और आवश्यकतानुसार इसे फिर से बनाएँ। कोई MyObj मनोरंजन की आवश्यकता नहीं है।

Answer 2

यहाँ देखें: http://docs.python.org/2/library/threading.html#threading.Thread.start

यह अधिकतम एक बार धागा वस्तु प्रति बुलाया जाना चाहिए। यह नियंत्रण के अलग थ्रेड में ऑब्जेक्ट की रन() विधि के लिए व्यवस्थित करने की व्यवस्था करता है।

यह विधि पर एक से अधिक थ्रेड ऑब्जेक्ट पर एक से अधिक बार बुलाए जाने पर RuntimeError को बढ़ाएगी।

एक धागा एक से अधिक बार चलाने का इरादा नहीं है। आप Thread Pool

Answer 3

का उपयोग करना चाहेंगे, मुझे विश्वास है कि Thread कक्षा को कैसे लागू किया जाता है। यह एक वास्तविक ओएस थ्रेड लपेटता है, ताकि थ्रेड को पुनरारंभ करने से वास्तव में इसकी पहचान बदल जाएगी, जो भ्रमित हो सकती है।

class Worker(object): 
    """ Implements the logic to be run in separate threads """ 
    def __call__(self): 
     # do useful stuff and change the state 

class Supervisor(): 
    def run(self, worker): 
     thr = None 
     while True: 
      if not thr or not thr.is_alive(): 
       thr = Thread(target=worker) 
       thr.daemon = True 
       thr.start() 
      thr.join(1) # give it some time 

:

धागे से निपटने के लिए एक बेहतर तरीका लक्ष्य कार्य/callables के माध्यम से वास्तव में है