2013-02-09 11 views
5

sto sperimentando alcuni problemi con questo codice:chiamata tubo e la sincronizzazione

#include <stdio.h> 
#include <stdlib.h> 

#define SIZE 30 
#define Error_(x) { perror(x); exit(1); } 
int main(int argc, char *argv[]) { 

    char message[SIZE]; 
    int pid, status, ret, fd[2]; 

    ret = pipe(fd); 
    if(ret == -1) Error_("Pipe creation"); 

    if((pid = fork()) == -1) Error_("Fork error"); 

    if(pid == 0){ //child process: reader (child wants to receive data from the parent) 
     close(fd[1]); //reader closes unused ch. 
     while(read(fd[0], message, SIZE) > 0) 
       printf("Message: %s", message); 
     close(fd[0]); 
    } 
    else{//parent: writer (reads from STDIN, sends data to the child) 
     close(fd[0]); 
     puts("Tipe some text ('quit to exit')"); 
     do{ 
      fgets(message, SIZE, stdin); 
      write(fd[1], message, SIZE); 
     }while(strcmp(message, "quit\n") != 0); 
     close(fd[1]); 
     wait(&status); 
    } 
} 

codice funziona bene, ma non riesco a spiegare perché! Non esiste una sincronizzazione esplicita tra processi padre e figlio. Se il processo figlio viene eseguito prima del genitore, read deve restituire 0 e il processo termina, ma per qualche motivo attende l'esecuzione del genitore. Come lo spieghi? Forse mi manca qualcosa.

(Edited)

+2

Perché ti aspetti che la lettura restituisca 0? Non stai impostando I/O non bloccante ovunque. – Mat

+1

... E non sarebbe 0 anche per I/O non bloccanti. –

+0

Il blocco 'read' per il processo? –

risposta

5

Dal momento che non è stato utilizzato in O_NONBLOCKpipe2, read sta bloccando per default. Pertanto attende che i dati vengano scritti nella pipe.

+0

Quando' (fd [0], messaggio, SIZE)> 0' in mentre la condizione è falsa? –

+0

Diventa falso quando il tubo è chiuso all'altra estremità; se non hai ancora scritto nulla, il lettore pensa che potresti voler scrivere qualcosa più tardi. IOW il pipe agisce come una sincronizzazione implicita. – loreb

+2

La pipe non è affatto implicita. È un meccanismo di sincronizzazione molto esplicito. Probabilmente il più comune. Probabilmente anche il più semplice. –