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 funktionen pipe () används för att implementera konceptet med hjälp av C -språk.
Om rör
I röret bibehålls data 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 skrivit till röret än, returnerar läs 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 feltillstånd och röret genererar en SIGPIPE -signal.
Rubrikfil
#omfattaSyntax
intrör(intfiledes[2])
Argument
Denna funktion tar ett enda argument, en array med två heltal ( filedes ). filedes [0] används för avläsning från röret, och filedes [1] används för att skriva till röret. Processen som vill läsa från röret bör stängas filedes [1], och processen som vill skriva till röret bör stängas filedes [0] . Om rörets onödiga ändar inte uttryckligen stängs, kommer filändning (EOF) aldrig att returneras.
Returvärden
På 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 du använder rörfunktionen på C -språk.
Exempel 1
I det här exemplet kommer vi att se hur rörfunktionen fungerar. Även om det inte är särskilt användbart att använda ett rör i en enda process, men vi får en idé.
// Exempel1.c#omfatta
#omfatta
#omfatta
#omfatta
inthuvud()
{
intn;
intfiledes[2];
rödingbuffert[1025];
röding *meddelande= 'Hej världen!';
rör(filedes);
skriva(filedes[1],meddelande, strlen (meddelande));
om ((n=läsa(filedes[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äsa');
utgång (0);
}
Här har vi först skapat ett rör med rör() funktionen skrivs sedan till röret med elfenben [1] slutet. Sedan har data lästs med hjälp av den andra änden av röret, vilket är filedes [0] . För att läsa och skriva till filen brukade vi läsa() och skriva() funktioner.
Exempel 2
I det här exemplet kommer vi att se hur föräldrar och barnprocesser kommunicerar med pipen.
// Exempel2.c#omfatta
#omfatta
#omfatta
#omfatta
#omfatta
inthuvud()
{
intfiledes[2],nbytes;
pid_t barnpid;
rödingsträng[] = 'Hej världen! n';
rödingreadbuffer[80];
rör(filedes);
om((barnbarn=gaffel()) == -1)
{
perror ('gaffel');
utgång (1);
}
om(barnbarn== 0)
{
stänga(filedes[0]);// Barnprocess behöver inte denna ände av röret
/ * Skicka 'sträng' genom rörets utmatningssida */
skriva(filedes[1],sträng, ( strlen (sträng)+1));
utgång (0);
}
annan
{
/ * Förälderprocess stänger utgångssidan av röret */
stänga(filedes[1]);// Förälderprocessen behöver inte denna ände av röret
/ * Läs i en sträng från röret */
nbytes=läsa(filedes[0],readbuffer, storlek av(readbuffer));
printf ('Läs sträng: %s',readbuffer);
}
lämna tillbaka(0);
}
Först har ett rör skapats med hjälp av rörfunktion, sedan har en underordnad process gafflats. Sedan stänger barnprocessen läsänden och skriver till röret. Moderprocessen 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 bara sett envägs dataflöde, en process skriver och en annan process läser, vilket skapar två rör som vi också kan uppnå dubbelriktat dataflöde.