Originalmente inviato da lagigliaivan

Non capisco molto bene questa pace di codice che hai scritto:

if(pid | pid1 == 0)//process A

 if ( pid | (pid1 == 0) )

Originalmente inviato da p00ndawg

pid = fork();
pid1 = fork();

Originalmente inviato da tetsujin

OK, prima fuori, hai un totale di quattro processi di qui, e non tre ... (E 'questo che volevi? Per il processo Chiedo a generare un largo tre figli? Oppure non si desidera tre processi totale?)

Un processo (processo originale): pid \u003d B, C \u003d PID1
Processo B (primo figlio di A): pid \u003d 0, PID1 \u003d D
Processo C (secondo figlio di A): pid \u003d B, PID1 \u003d 0
Processo di D (figlio di B): pid \u003d 0, PID1 \u003d 0



Questa dichiarazione, se verrà effettivamente pubblicato per tre dei quattro processi: A, C, e D:
Processo A: (pid | PID1 \u003d\u003d 0) \u003d (B | C \u003d\u003d 0) \u003d (B | 0) \u003d true
Processo B: (pid | PID1 \u003d\u003d 0) \u003d (0 | D \u003d\u003d 0) \u003d (0 | 0) \u003d false
Processo C: (pid | PID1 \u003d\u003d 0) \u003d (B | 0 \u003d\u003d 0) \u003d (B | true) \u003d true
Processo D: (pid | PID1 \u003d\u003d 0) \u003d (0 | 0 \u003d\u003d 0) \u003d (0 | true) \u003d true
(dove VERO nonzero valore è di circa ...)



p [2] è non inizializzato. pipe () crea solo due descrittori di file: p [0], Leggere la fine del tubo, e p [1], Scrivere la fine del tubo.

Inoltre, dalla descrizione del problema che suonava come avete voluto ciascuno dei tre processi di comunicazione hanno la capacità di scrivere e ricevere messaggi da ciascuno degli altri due processi di comunicare. Ciò suggerisce che devi creare almeno tre tubi (tre invocazioni di tubo () nel processo padre). Dico "almeno tre tubi", perché se questi processi sono in esecuzione contemporaneamente, due processi che consentono di scrivere lo stesso file Descrittore potrebbero avere risultati imprevedibili. (Uso di scrivere () per scrivere una sola, tutto il messaggio sarà probabilmente sicuro -, ma se il messaggio è stato grande, è possibile scrivere la blocca in attesa per il lettore a leggere alcuni dati fuori - nel qual caso credo che sia possibile, il processo di scrittura di altri () potrebbe ottenere vento fino a prima della prima write () termina il suo messaggio. (Non sono sicuro, però. write () è una chiamata di sistema in modo che il kernel potrebbe sincronizzati ...)

Ricorda che il tubo () crea due descrittori di file, ma un solo tubo. Un tubo con un input e un output fine fine. Un descrittore di file che ricevete dal tubo () sia di sola lettura o la scrittura solo - non si può mai leggere e scrivere dallo stesso descrittore di file, quando il descrittore di file è stato ottenuto con il tubo ().

Originalmente inviato da p00ndawg

sì ho voluto processi A, B, C e comunicare gli uni con gli altri, ma volevo solo tubo di un messaggio da un-> b-> c. I didnt realizzare avevo creato 4 processi.
C'è comunque a creare solo 3 processi? come a un modo per ottenere solo i tubi variabile comunicare gli uni con gli altri?

Originalmente inviato da tetsujin

Sicuro. Il motivo è conclusa con un totale di quattro processi perché ogni chiamata alla fork () ritorna due volte: una volta nel processo originale e una volta in quella nuova. Quindi, dopo aver effettuato la prima chiamata a fork (), vi sono due processi - che sia di andare a chiamare il secondo fork ().

Per creare un totale di tre processi, assicurarsi di forcella solo due volte. È possibile effettuare questa operazione controllando il valore di ritorno di fork () per assicurarsi che siete nel processo che dovrebbe forcella.

pid_b = fork();
if (pid_b == 0)
{
    /* fork() returned 0, so this is the new process, which I call process B. */
    pid_c = fork();
    if (pid_c == 0)
    {
        /* This is process C... */
    }
}

pipe(channel_ab);
 pid_b = fork();
if (pid_b > 0)
{
    /* Process A...  Send messages to B using channel_ab[1] */
    close(channel_ab[0]);
    write(channel_ab[1], msg, size);
} else if (pid_b == 0) {
    /* Process B */
    close(channel_ab[1]);

    pipe(channel_bc);
    pid_c = fork();
    if (pid_c > 0)
    {
        /* Still process B.  Receive messages from A using channel_ab[0], send messages to C using channel_bc[1]. */
        close(channel_bc[0]);
        msg_size = read(channel_ab[0], buffer, size);
        write(channel_bc[1], msg, size);
    } else if (pid_c == 0) {
        /* Process C.  Receive messages from B using channel_bc[0]. */
        msg_size = read(channel_bc[0], buffer, size);
    }
}