Phenquestions
Ett rör är ett medium för kommunikation mellan processer. En process skriver data till röret, och en annan process läser data från röret. I den här artikeln kommer vi att se hur pipen () -funktionen används för att implementera konceptet med C-språk.
Om Pipe
I röret bibehålls datan i en FIFO-ordning, vilket innebär att man skriver data till ena änden av röret sekventiellt och läser data från en annan ände av röret i samma sekventiella ordning.
Om någon process läser från röret, men ingen annan process inte har skrivits till röret ännu, läser returnerar slutet av filen. Om en process vill skriva till ett rör, men det inte finns någon annan process kopplad till röret för avläsning, är detta ett felförhållande och röret genererar en SIGPIPE-signal.
Rubrikfil
#omfattaSyntax
int pipe (int arkiverar [2])Argument
Denna funktion tar ett enda argument, en matris med två heltal (lämnar in). lämnar in [0] används för avläsning från röret, och lämnar in [1] används för att skriva till röret. Processen som vill läsa från röret bör avslutas lämnar in [1], och processen som vill skriva till röret bör avslutas lämnar in [0]. Om de onödiga ändarna på röret inte stängs uttryckligen kommer EOF (end-of-file) aldrig att returneras.
Returnera värden
När det gäller framgång, rör() returnerar 0, för fel returnerar funktionen -1.
Bildmässigt kan vi representera rör() fungerar enligt följande:
Nedan följer några exempel som visar hur man använder rörfunktionen på C-språk.
Exempel 1
I det här exemplet ser vi hur rörfunktionen fungerar. Att använda ett rör i en enda process är inte särskilt användbart, men vi får en idé.
// Exempel1.c#omfatta
#omfatta
#omfatta
#omfatta
int main ()
int n;
int lämnar in [2];
kolbuffert [1025];
char * message = "Hej världen!";
pipe (filedes);
skriva (arkiverar [1], meddelande, strlen (meddelande));
om ((n = läst (arkiverar [0], buffert, 1024))> = 0)
buffert [n] = 0; // avsluta strängen
printf ("läs% d byte från röret:"% s "\ n", n, buffert);
annan
perror ("läs");
exit (0);
Här har vi först skapat ett rör med rör() funktion skrivs sedan till röret med filter [1] slutet. Sedan har data lästs med den andra änden av röret, vilket är lämnar in [0]. För att läsa och skriva till filen brukade vi läsa() och skriva() funktioner.
Exempel 2
I det här exemplet ser vi hur föräldra- och barnprocesser kommunicerar med röret.
// Exempel2.c#omfatta
#omfatta
#omfatta
#omfatta
#omfatta
int main ()
int arkiverar [2], nbytes;
pid_t barnpid;
char string [] = "Hej världen!\ n ";
char readbuffer [80];
pipe (filedes);
om ((barnpinne = gaffel ()) == -1)
perror ("gaffel");
utgång (1);
if (childpid == 0)
stäng (arkiverar [0]); // Barnprocessen behöver inte denna ände av röret
/ * Skicka "sträng" genom utgångssidan av röret * /
skriv (arkiverar [1], sträng, (strlen (sträng) +1));
exit (0);
annan
/ * Föräldraprocessen stänger rörets utgångssida * /
close (filedes [1]); // Föräldraprocessen behöver inte denna ände av röret
/ * Läs i en sträng från röret * /
nbytes = read (filedes [0], readbuffer, sizeof (readbuffer));
printf ("Lässträng:% s", läsbuffert);
retur (0);
Först har ett rör skapats med hjälp av rörfunktionen, sedan har en underordnad process gafflats. Därefter stänger barnprocessen avläsningsänden och skriver till röret. Föräldraprocessen stänger skrivänden och läser från röret och visar den. Här är dataflöde bara ett sätt som är från barn till förälder.
Slutsats:
rör() är ett kraftfullt systemanrop i Linux. I den här artikeln har vi sett endast envägs dataflöde, en process skriver och en annan process läser, vilket skapar två rör som vi kan uppnå dubbelriktat dataflöde.
