फोर्क पैरेंट बाल संचार

Question

मुझे प्रत्येक बच्चे के साथ अलग-अलग संवाद करने के लिए मूल प्रक्रिया के लिए कुछ तरीका चाहिए।

मेरे कुछ बच्चे हैं जिन्हें माता-पिता के साथ अलग-अलग बच्चों से अलग संवाद करने की आवश्यकता है।

क्या माता-पिता के लिए प्रत्येक बच्चे के साथ निजी संचार चैनल रखने का कोई तरीका है?

उदाहरण के लिए एक बच्चा भी माता-पिता को एक संरचना चर भेज सकता है?

मैं इस तरह की चीजों के लिए नया हूं इसलिए किसी भी मदद की सराहना की जाती है। धन्यवाद

Answer 1

(मैं बस मान लेंगे हम यहाँ linux बात कर रहे हैं)

आप शायद पता चला के रूप में, fork() ही बस बुला प्रक्रिया नकल जाएगा, यह IPC संभाल नहीं करता है।

कांटा मैनुअल से:

कांटा() बुला प्रक्रिया को दोहराने के लिए एक नई प्रक्रिया पैदा करता है। नई प्रक्रिया जिसे बच्चे के रूप में जाना जाता है, कॉलिंग प्रक्रिया का सटीक डुप्लिकेट है, जिसे माता-पिता के रूप में जाना जाता है।

सबसे आम तरीका आईपीसी को संभालने के लिए एक बार आप काँटेदार() पाइप का उपयोग करने के, खासकर यदि आप चाहते हैं "प्रत्येक बच्चे के साथ एक निजी कम्युनिकेशन चैनल" है। इधर, एक आप pipe के मैनुअल में पा सकते हैं (वापसी मान जाँच नहीं कर रहे हैं) के लिए इसी तरह के प्रयोग का एक विशिष्ट और आसान उदाहरण है:

1. जनक:

   #include <sys/wait.h> 
       #include <stdio.h> 
       #include <stdlib.h> 
       #include <unistd.h> 
       #include <string.h> 
   
       int 
       main(int argc, char * argv[]) 
       { 
        int pipefd[2]; 
        pid_t cpid; 
        char buf; 
   
        pipe(pipefd); // create the pipe 
        cpid = fork(); // duplicate the current process 
        if (cpid == 0) // if I am the child then 
        { 
         close(pipefd[1]); // close the write-end of the pipe, I'm not going to use it 
         while (read(pipefd[0], &buf, 1) > 0) // read while EOF 
          write(1, &buf, 1); 
         write(1, "\n", 1); 
         close(pipefd[0]); // close the read-end of the pipe 
         exit(EXIT_SUCCESS); 
        } 
        else // if I am the parent then 
        { 
         close(pipefd[0]); // close the read-end of the pipe, I'm not going to use it 
         write(pipefd[1], argv[1], strlen(argv[1])); // send the content of argv[1] to the reader 
         close(pipefd[1]); // close the write-end of the pipe, thus sending EOF to the reader 
         wait(NULL); // wait for the child process to exit before I do the same 
         exit(EXIT_SUCCESS); 
        } 
        return 0; 
       } 
   

   कोड सुंदर आत्म व्याख्यात्मक है पाइप से कांटे()

2. बाल पढ़ता है() EOF तक
3. जनक लिखते हैं() पाइप को तो बंद कर देता है() यह
4. Datas साझा किया गया है, हुर्रे!

वहां से आप जो कुछ भी चाहते हैं वह कर सकते हैं; बस अपने रिटर्न वैल्यू को जांचना और dup, pipe, fork, wait ... मैनुअल पढ़ने के लिए याद रखें, वे काम में आ जाएंगे।

वहाँ भी प्रक्रियाओं के बीच datas साझा करने के लिए अन्य तरीकों का एक समूह रहे हैं, वे आपकी रुचि migh हालांकि वे अपने "निजी" की आवश्यकता को पूरा नहीं करते हैं:

• shared memory "SHM", नाम का कहना है कि यह सब ...
• sockets, वे स्पष्ट रूप से के रूप में अच्छा काम करता है, तो स्थानीय स्तर पर इस्तेमाल किया
• FIFO files जो मूल रूप से एक नाम

या पूर्व संध्या के साथ पाइप रहे हैं ना सरल फ़ाइल ... (मैंने एक बार प्रक्रियाओं के बीच बाइनरी डेटा भेजने के लिए SIGUSR1/2 signals का भी उपयोग किया है ... लेकिन मैं उस हाहा की अनुशंसा नहीं करूंगा।) और शायद कुछ और जो मैं अभी इस बारे में नहीं सोच रहा हूं ।

शुभकामनाएं।