दिलचस्प पोस्ट
Bash में, मैं एक कमांड में फ़ंक्शन कुंजी कैसे बाँधूं? सी # में कमांड-लाइन आर्ग्यूमेंट पास करना प्रोग्रामेटिक रूप से उत्पन्न ग्रेडीयंट्स? IOS UIImage क्लिप को पथ एएसपी.नेट क्या अन्य नियंत्रणों के नियंत्रण में कोई बेहतर तरीका है? त्रुटि: java: javacTask: स्रोत रिलीज़ 8 को लक्ष्य रिलीज 1.8 की आवश्यकता है कॉलम के लिए प्रारूप स्ट्रिंग का उपयोग करके फ़्लैंड्स के पांडा डेटाफ़्रेम को कैसे प्रदर्शित किया जाए? टैग के बीच पाठ निकालने के लिए जावा रेगेक्स जो @NotNull जावा एनोटेशन मैं उपयोग करना चाहिए? स्प्लिट फ़ंक्शन जोड़ें: \ xef \ xbb \ xbf … \ n मेरी सूची में क्या मुझे जावा स्विंग में सेट के उपयोग से बचने के लिए (पसंदीदा | अधिकतम | न्यूनतम) आकार तरीकों से बचाना चाहिए? Office 365 रेस्ट API – डेमॉन सप्ताह प्रमाणीकरण मैं Jetty 9 में तत्काल वेबसॉकेट का उपयोग कैसे करूं? दो स्टैक का प्रयोग करके कतार कैसे कार्यान्वित करें? WebView, एक HTML पृष्ठ में स्थानीय .CSS फ़ाइल जोड़ें?

सभी धागे समाप्त होने तक अजगर मल्टीथ्रेडिंग प्रतीक्षा करें

यह एक समान संदर्भ में पूछा गया हो सकता है लेकिन मुझे 20 मिनट के बाद खोज करने में असमर्थ था, इसलिए मैं पूछूंगा।

मैंने एक पायथन स्क्रिप्ट लिखी है (कह देता है: scriptA.py) और एक स्क्रिप्ट (स्क्रिप्ट B.py का कहना है)

स्क्रिप्ट बी में मैं विभिन्न तर्कों के साथ कई बार पटकथा कॉल करना चाहता हूं, हर बार चलाने के लिए करीब एक घंटे लग जाता है, (यह एक बड़ी स्क्रिप्ट है, बहुत सी चीजें हैं … इसके बारे में चिंता मत करो) और मैं इसे चलाने में सक्षम होना चाहता हूं एक साथ सभी विभिन्न तर्कों के साथ scriptA, लेकिन मैं इंतजार करने की आवश्यकता है जब तक कि उन सभी को जारी रखने से पहले किया जाता है; मेरा कोड:

import subprocess #setup do_setup() #run scriptA subprocess.call(scriptA + argumentsA) subprocess.call(scriptA + argumentsB) subprocess.call(scriptA + argumentsC) #finish do_finish() 

मैं सभी subprocess.call() को एक ही समय में चलाने के लिए करना चाहता हूं, और तब तक इंतजार करें जब तक कि वे पूरी तरह से काम न करें, मुझे यह कैसे करना चाहिए?

मैंने थ्रेडिंग का उपयोग उदाहरण के लिए करने की कोशिश की:

 from threading import Thread import subprocess def call_script(args) subprocess.call(args) #run scriptA t1 = Thread(target=call_script, args=(scriptA + argumentsA)) t2 = Thread(target=call_script, args=(scriptA + argumentsB)) t3 = Thread(target=call_script, args=(scriptA + argumentsC)) t1.start() t2.start() t3.start() 

लेकिन मुझे नहीं लगता कि यह सही है।

मुझे कैसे पता चलेगा कि वे मेरे do_finish() जाने से पहले समाप्त हो चुके हैं?

Solutions Collecting From Web of "सभी धागे समाप्त होने तक अजगर मल्टीथ्रेडिंग प्रतीक्षा करें"

आपको स्क्रिप्ट के अंत में Thread ऑब्जेक्ट में शामिल होने की विधि का उपयोग करना होगा।

 t1 = Thread(target=call_script, args=(scriptA + argumentsA)) t2 = Thread(target=call_script, args=(scriptA + argumentsB)) t3 = Thread(target=call_script, args=(scriptA + argumentsC)) t1.start() t2.start() t3.start() t1.join() t2.join() t3.join() 

इस प्रकार मुख्य धागा t1 , t1 और t3 खत्म निष्पादन तक इंतजार करेगा।

धागे को एक सूची में रखें और फिर जुड़ें विधि का उपयोग करें

  threads = [] t = Thread(...) threads.append(t) ...repeat as often as necessary... # Start all threads for x in threads: x.start() # Wait for all of them to finish for x in threads: x.join() 

मैं इनपुट सूची के आधार पर सूची समझ का उपयोग करना पसंद करता हूं:

 inputs = [scriptA + argumentsA, scriptA + argumentsB, ...] threads = [Thread(target=call_script, args=(i)) for i in inputs] [t.start() for t in threads] [t.join() for t in threads] 

पायथन 3 में, पायथन 3.2 के बाद से एक ही नतीजे तक पहुंचने के लिए एक नया दृष्टिकोण है, कि मैं व्यक्तिगत रूप से पारंपरिक धागे बनाने / शुरू / शामिल होने के लिए पसंद करता हूं, पैकेज concurrent.futures : https://docs.python.org/3/library/ concurrent.futures.html

ThreadPoolExecutor का उपयोग करना कोड होगा:

 from concurrent.futures.thread import ThreadPoolExecutor def call_script(arg) subprocess.call(scriptA + arg) args = [argumentsA, argumentsB, argumentsC] with ThreadPoolExecutor(max_workers=2) as executor: for arg in args: executor.submit(call_script, arg) print('All tasks has been finished') 

एक लाभ यह है कि आप अधिकतम समवर्ती श्रमिकों को स्थापित करने के माध्यम से नियंत्रित कर सकते हैं।

आप नीचे की तरह कुछ वर्ग कर सकते हैं, जिसमें से आप 'एन' संख्याओं को जोड़ सकते हैं या कंसोल_स्क्रिप्ट जो आप समानांतर जुनून में निष्पादित करना चाहते हैं और निष्पादन को शुरू करते हैं और सभी कार्यों को पूरा करने के लिए प्रतीक्षा करें ..

 from multiprocessing import Process class ProcessParallel(object): """ To Process the functions parallely """ def __init__(self, *jobs): """ """ self.jobs = jobs self.processes = [] def fork_processes(self): """ Creates the process objects for given function deligates """ for job in self.jobs: proc = Process(target=job) self.processes.append(proc) def start_all(self): """ Starts the functions process all together. """ for proc in self.processes: proc.start() def join_all(self): """ Waits untill all the functions executed. """ for proc in self.processes: proc.join() def two_sum(a=2, b=2): return a + b def multiply(a=2, b=2): return a * b #How to run: if __name__ == '__main__': #note: two_sum, multiply can be replace with any python console scripts which #you wanted to run parallel.. procs = ProcessParallel(two_sum, multiply) #Add all the process in list procs.fork_processes() #starts process execution procs.start_all() #wait until all the process got executed procs.join_all() 

शायद, ऐसा कुछ

 for t in threading.enumerate(): if t.daemon: t.join()