एकाधिक कांटा() Concurrency

Question

आप फोर्क() कमांड का उपयोग इस तरह से करते हैं कि आप 10 प्रक्रियाओं को बढ़ा सकते हैं और उन्हें एक साथ एक छोटा सा कार्य कर सकते हैं।

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

धन्यवाद।

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

Answer 1

कॉल fork():

जोड़ना कोड टिप्पणी प्रति बच्चों के लिए प्रतीक्षा करने के लिए:

int numberOfChildren = 10; 
pid_t *childPids = NULL; 
pid_t p; 

/* Allocate array of child PIDs: error handling omitted for brevity */ 
childPids = malloc(numberOfChildren * sizeof(pid_t)); 

/* Start up children */ 
for (int ii = 0; ii < numberOfChildren; ++ii) { 
    if ((p = fork()) == 0) { 
     // Child process: do your work here 
     exit(0); 
    } 
    else { 
     childPids[ii] = p; 
    } 
} 

/* Wait for children to exit */ 
int stillWaiting; 
do { 
    stillWaiting = 0; 
    for (int ii = 0; ii < numberOfChildren; ++ii) { 
     if (childPids[ii] > 0) { 
      if (waitpid(childPids[ii], NULL, WNOHANG) != 0) { 
      /* Child is done */ 
      childPids[ii] = 0; 
      } 
      else { 
      /* Still waiting on this child */ 
      stillWaiting = 1; 
      } 
     } 
     /* Give up timeslice and prevent hard loop: this may not work on all flavors of Unix */ 
     sleep(0); 
    } 
} while (stillWaiting); 

/* Cleanup */ 
free(childPids); 

Answer 2

प्रत्येक "एक" के बाद एक बच्चे को जन्म देने वाली "मुख्य" प्रक्रिया में बस लूप प्रत्येक के साथ एक विशेष कार्य निर्दिष्ट करता है।

Answer 3

जब आप प्रक्रियाओं को फोर्क करते हैं तो वे एक साथ चल रहे होंगे। लेकिन ध्यान दें कि जब तक आपके पास पर्याप्त उपलब्ध निष्क्रिय प्रोसेसर नहीं हैं, तो वे वास्तव में एक साथ निष्पादित नहीं हो सकते हैं, जो वास्तव में कोई फर्क नहीं पड़ता ...

आपका दूसरा पैराग्राफ ऐसा लगता है जैसे आप समझ नहीं रहे हैं कि आपके पास कांटा कैसे काम करता है यह देखने के लिए रिटर्न कोड जांचने के लिए कि क्या आप माता-पिता में हैं या फोर्क प्रक्रिया में हैं। तो आप माता-पिता को 10 प्रक्रियाओं को फोर्क करने के लिए एक लूप चलाते हैं, और बच्चों में आप जो कुछ भी करना चाहते हैं, वह करते हैं। एक पाश में

Answer 4

तुम भी POSIX धागे (या pthreads) में देखना चाहते हो सकता है। (अपने टैग में)

https://computing.llnl.gov/tutorials/pthreads/