Comunicazione fork parent genitore

Question

Ho bisogno di un modo per il processo genitore di comunicare separatamente con ciascun figlio.

Ho alcuni bambini che hanno bisogno di comunicare con il genitore separatamente dagli altri bambini.

C'è un modo per un genitore di avere un canale di comunicazione privato con ogni bambino?

Inoltre, ad esempio un bambino può inviare al padre una variabile struct?

Sono nuovo per questo genere di cose quindi ogni aiuto è apprezzato. Grazie

Answer 1

(mi limiterò a supporre che stiamo parlando linux qui)

Come probabilmente hai scoperto, fork() stesso sarà solo duplicare il processo chiamante, non gestisce IPC.

Da manuale forcella:

fork() crea un nuovo processo duplicando il processo chiamante. Il nuovo processo, denominato figlio, è un duplicato esatto di processo chiamante, denominato genitore.

Il modo più comune per gestire IPC una volta che si è forked() è utilizzare le pipe, soprattutto se si desidera "una comunicazione privata con ogni bambino". Ecco un tipico esempio e facilità d'uso, simile a quella che si può trovare nel manuale pipe (valori di ritorno non vengono controllati):

#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; 
    } 

Il codice è abbastanza auto-esplicativo:

1. Parent forche()
2. il bambino legge() dal tubo fino EOF
Parent
3. scrive() per il tubo si chiude quindi() è
4. Dati sono stati condivisi, evviva!

Da lì puoi fare tutto ciò che vuoi; ricordati di controllare i valori di ritorno e di leggere i manuali dup, pipe, fork, wait ..., saranno utili.

ci sono anche un sacco di altri modi per condividere dati tra processi, essi migh interessano voi anche se non soddisfano le vostre esigenze "privato":

• shared memory "SHM", il nome dice tutto ...
• sockets, ovviamente lavorare come buono se usato localmente
• FIFO files che sono fondamentalmente i tubi con un nome

o eve Un semplice file ... (Ho persino usato SIGUSR1/2 signals per inviare dati binari tra i processi una volta ... Ma non lo consiglierei ahaha.) E probabilmente un po 'di più a cui non sto pensando in questo momento .

Buona fortuna.