Phenquestions
Een pijp is een medium voor communicatie tussen processen. Het ene proces schrijft gegevens naar de pijp en een ander proces leest de gegevens uit de pijp. In dit artikel zullen we zien hoe de functie pipe() wordt gebruikt om het concept te implementeren met behulp van C-taal.
Over pijp
In de pijp worden de gegevens in een FIFO-volgorde bijgehouden, wat betekent dat gegevens achtereenvolgens naar het ene uiteinde van de pijp worden geschreven en gegevens van een ander uiteinde van de pijp in dezelfde volgorde worden gelezen.
Als een proces van de pijp leest, maar er is nog geen ander proces naar de pijp geschreven, dan retourneert read het einde van het bestand. Als een proces naar een pijp wil schrijven, maar er is geen ander proces aan de pijp gekoppeld om te lezen, dan is dit een foutconditie en genereert de pijp een SIGPIPE-signaal.
Header-bestand
#includeSyntaxis
int-pijp (int-files[2])Argumenten
Deze functie heeft één argument nodig, een array van twee gehele getallen (gearchiveerd). bestanden[0] wordt gebruikt voor het lezen van de pijp, en bestanden[1] wordt gebruikt om naar de pijp te schrijven. Het proces dat van de pijp wil lezen, moet sluiten bestanden[1], en het proces dat naar de pijp wil schrijven, moet sluiten bestanden[0]. Als de onnodige uiteinden van de pijp niet expliciet worden gesloten, wordt het einde van het bestand (EOF) nooit geretourneerd.
Retourwaarden
Bij succes, de pijp() retourneert 0, voor mislukking retourneert de functie -1.
Picturaal kunnen we de vertegenwoordigen pijp() functioneren als volgt:
Hieronder staan een paar voorbeelden die laten zien hoe de pipe-functie in C-taal gebruikt kan worden.
Voorbeeld 1
In dit voorbeeld zullen we zien hoe de pijpfunctie werkt. Hoewel het gebruik van een pijp in een enkel proces niet erg handig is, maar we zullen een idee krijgen.
// Voorbeeld 1.c#include
#include
#include
#include
int hoofd()
int n;
int-bestanden[2];
char-buffer [1025];
char *message = "Hallo wereld!";
pijp (filedes);
write(filedes[1], bericht, strlen(bericht));
if ((n = lezen ( files [0], buffer, 1024 ) ) >= 0)
buffer[n] = 0; // beëindig de string
printf("lees %d bytes uit de pijp: "%s"\n", n, buffer);
anders
perror("lezen");
uitgang(0);
Hier hebben we eerst een pijp gemaakt met pijp() functie vervolgens naar de pijp geschreven met behulp van fildes[1] einde. Vervolgens zijn de gegevens gelezen met behulp van het andere uiteinde van de pijp, namelijk: bestanden[0]. Voor het lezen en schrijven naar het bestand gebruikten we: lezen() en schrijven() functies.
Voorbeeld2
In dit voorbeeld zullen we zien hoe bovenliggende en onderliggende processen communiceren met behulp van de pipe.
// Voorbeeld2.c#include
#include
#include
#include
#include
int hoofd()
int-bestanden[2], nbytes;
pid_t kindpid;
char string[] = "Hallo wereld!\n";
char leesbuffer [80];
pijp (filedes);
if((childpid = fork()) == -1)
perror("vork");
uitgang(1);
if(childpid == 0)
close(filedes[0]);//Het kindproces heeft dit uiteinde van de pijp niet nodig
/* Stuur "string" door de uitvoerzijde van de pijp */
write(filedes[1], string, (strlen(string)+1));
uitgang(0);
anders
/* Bovenliggend proces sluit uitvoerzijde van pijp */
close(filedes[1]);//Het bovenliggende proces heeft dit uiteinde van de pijp niet nodig
/* Lees een string in uit de pijp */
nbytes = read(filedes[0], readbuffer, sizeof(readbuffer));
printf("Lees string: %s", leesbuffer);
retour(0);
Eerst is er één pijp gemaakt met behulp van de pijpfunctie en vervolgens is er een onderliggend proces gevorkt. Vervolgens sluit het onderliggende proces het leeseinde en schrijft naar de pijp. Het bovenliggende proces sluit het schrijfeinde en leest van de pijp en geeft het weer. Hier is de gegevensstroom slechts één manier, namelijk van kind naar ouder.
Conclusie:
pijp() is een krachtige systeemaanroep in Linux. In dit artikel hebben we alleen een eenrichtingsgegevensstroom gezien, één proces schrijft en een ander proces leest, waardoor we twee pijpen creëren, we kunnen ook een bidirectionele gegevensstroom bereiken.
