फोर्क() के माध्यम से एकाधिक उपप्रोसेसेस चलाने का सबसे अच्छा तरीका क्या है?

Question

एक पायथन लिपि को फोर्क() के माध्यम से एकाधिक उप-प्रक्रियाओं को विकसित करने की आवश्यकता है। उन सभी बच्चों की प्रक्रियाओं को एक साथ चलाना चाहिए और माता-पिता की प्रक्रिया पूरी होने के लिए प्रतीक्षा करनी चाहिए। "धीमे" बच्चे पर कुछ टाइमआउट सेट करने की क्षमता होने से अच्छा होगा। सभी बच्चों को एकत्र किए जाने के बाद मूल प्रक्रिया स्क्रिप्ट को संसाधित करने पर जाती है।

इसे काम करने का सबसे अच्छा तरीका क्या है? धन्यवाद।

Answer 1

सरल उदाहरण:

import os 
chidren = [] 
for job in jobs: 
    child = os.fork() 
    if child: 
     children.append(child) 
    else: 
     pass # really should exec the job 
for child in children: 
    os.waitpid(child, 0) 

समय बाहर एक धीमी गति से बच्चे को एक छोटे से अधिक काम है, आप waitpid के बजाय wait का उपयोग कर सकते हैं, और बदले में बदले गए मूल्यों को बच्चों की सूची से हटा सकते हैं, बदले में प्रत्येक के रूप में (यहां पर) प्रतीक्षा कर सकते हैं। यदि आप SIGALRM हैंडलर के साथ alarm सेट अप करते हैं, तो आप निर्दिष्ट विलंब के बाद प्रतीक्षा को समाप्त कर सकते हैं। यह सभी मानक यूनिक्स सामान है, पायथन-विशिष्ट नहीं ...

Answer 2

क्या आपने pyprocessing मॉड्यूल देखा है?

Answer 3

उप-प्रक्रियाओं के साथ संवाद करने के लिए पारंपरिक, यूनिक्स-वाई तरीका अपने मानक इनपुट/आउटपुट में पाइप खोलना है, और select() सिस्टम कॉल का उपयोग मूल प्रक्रिया में संचार को मल्टीप्लेक्स करने के लिए करें (पायथन में उपलब्ध ... select मॉड्यूल)।

यदि आपको धीमी गति से चलने वाली बाल प्रक्रिया को मारने की आवश्यकता है, तो आप इसकी प्रक्रिया आईडी को सहेज सकते हैं (os.fork() कॉल द्वारा लौटाया गया) और फिर os.kill() का उपयोग करने के लिए इसे अब मारने के लिए उपयोग करें। बेशक, यह स्पष्ट रूप से बाल प्रक्रिया के साथ संवाद करने में सक्षम होने के लिए क्लीनर होगा और इसे बंद करने के लिए बताएं।

Answer 4

एपमेन्ट: आपके कोड में प्रत्येक बच्चा अपने काम के समाप्त होने के बाद लूप में रहेगा। वह बार-बार फोर्क करेगा। इसके अलावा, बच्चे जो शुरू होते हैं [] खाली नहीं होते हैं, वे लूप के अंत में अपने कुछ भाइयों की प्रतीक्षा करने का प्रयास करेंगे। आखिरकार कोई दुर्घटनाग्रस्त हो जाएगा। यह एक कामकाज है:

import os, time 

def doTheJob(job): 
    for i in xrange(10): 
     print job, i 
     time.sleep(0.01*ord(os.urandom(1))) 
     # random.random() would be the same for each process 

jobs = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"] 
imTheFather = True 
children = [] 

for job in jobs: 
    child = os.fork() 
    if child: 
     children.append(child) 
    else: 
     imTheFather = False 
     doTheJob(job) 
     break 

# in the meanwhile 
# ps aux|grep python|grep -v grep|wc -l == 11 == 10 children + the father 

if imTheFather: 
    for child in children: 
     os.waitpid(child, 0)