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 gehouden, 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 uit 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
#erbij betrekkenSyntaxis
intpijp(intgearchiveerd[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 end-of-file (EOF) nooit geretourneerd.
Retourwaarden
Bij succes, de pijp() retourneert 0, voor falen retourneert de functie -1.
Picturaal kunnen we de vertegenwoordigen pijp() functioneren als volgt:
Hieronder vindt u enkele voorbeelden die laten zien hoe u de pipe-functie in C-taal kunt gebruiken.
Voorbeeld 1
In dit voorbeeld zullen we zien hoe de pipe-functie werkt. Hoewel het gebruik van een pijp in een enkel proces niet erg handig is, maar we zullen een idee krijgen.
// Voorbeeld1.c#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
inthoofd()
{
intN;
intgearchiveerd[2];
charbuffer[1025];
char *bericht= 'Hallo Wereld!';
pijp(gearchiveerd);
schrijven(gearchiveerd[1],bericht, strlen (bericht));
indien ((N=lezen(gearchiveerd[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 ivoor [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 pijp.
// Voorbeeld2.c#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
inthoofd()
{
intgearchiveerd[2],nbytes;
pid_t childpid;
charsnaar[] = 'Hallo Wereld!N';
charleesbuffer[80];
pijp(gearchiveerd);
indien((kinderachtig=vork()) == -1)
{
perror ('vork');
Uitgang (1);
}
indien(kinderachtig== 0)
{
dichtbij(gearchiveerd[0]);// Kindproces heeft dit uiteinde van de pijp niet nodig
/* Stuur 'string' door de uitvoerzijde van de pijp */
schrijven(gearchiveerd[1],snaar, ( strlen (snaar)+1));
Uitgang (0);
}
anders
{
/* Bovenliggend proces sluit uitvoerzijde van pijp */
dichtbij(gearchiveerd[1]);// Ouderproces heeft dit uiteinde van de pijp niet nodig
/* Lees een string in uit de pijp */
nbytes=lezen(gearchiveerd[0],leesbuffer, De grootte van(leesbuffer));
printf ('Lees string: %s',leesbuffer);
}
opbrengst(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 deze 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 hebben gemaakt waarmee we ook een bidirectionele gegevensstroom kunnen bereiken.