Phenquestions
A cső közeg a folyamatok közötti kommunikációhoz. Az egyik folyamat adatokat ír a csőbe, a másik pedig a csőből kiolvassa az adatokat. Ebben a cikkben meglátjuk, hogyan használják a pipe () függvényt a koncepció C nyelvű megvalósításához.
Pipe-ról
A csőben az adatokat FIFO sorrendben tartják fenn, ami azt jelenti, hogy adatokat egymás után írunk a cső egyik végére, és ugyanabban a sorrendben olvassuk le az adatokat a cső másik végéből.
Ha bármely folyamat leolvas a csőből, de még nem írt más folyamatot a csőbe, akkor a read visszaadja a fájl végét. Ha egy folyamat írni akar egy csőre, de nincs más folyamat csatolva a csőhöz olvasás céljából, akkor ez hibaállapot, és a cső SIGPIPE jelet generál.
Fejlécfájl
#includeSzintaxis
int cső (int filedes [2])Érvek
Ez a függvény egyetlen argumentumot, két egész tömböt vesz fel (filedes). filedes [0] a csőből történő leolvasásra szolgál, és filedes [1] a csőhöz való íráshoz használják. A csőből leolvasható folyamatnak le kell zárulnia filedes [1], és le kell zárnia a folyamatot, amely a csőhöz akar írni filedes [0]. Ha a cső felesleges végei nincsenek kifejezetten bezárva, akkor a fájl vége (EOF) soha nem kerül visszaadásra.
Visszatérési értékek
A sikeren a cső() 0-t ad vissza, hiba esetén a függvény -1-et ad vissza.
Képileg képviselhetjük a cső() az alábbiak szerint működik:
Az alábbiakban bemutatunk néhány példát, amelyek bemutatják, hogyan kell használni a pipe függvényt C nyelven.
1. példa
Ebben a példában megnézzük, hogyan működik a csőfunkció. Bár egy cső egyetlen folyamatban történő használata nem túl hasznos, de fogunk kapni egy ötletet.
// Példa1.c#include
#include
#include
#include
int main ()
int n;
int filedes [2];
char puffer [1025];
char * message = "Helló, Világ!";
cső (filedes);
ír (filedes [1], üzenet, strlen (üzenet));
ha ((n = olvas (filedes [0], puffer, 1024))> = 0)
puffer [n] = 0; // megszünteti a karakterláncot
printf ("olvassa el a% d bájtot a csövön:"% s "\ n", n, puffer);
más
perror ("olvasni");
kilépés (0);
Itt hoztunk létre először egy csövet cső() függvényt, majd a csőhöz írjuk filde [1] vége. Ezután az adatokat leolvastuk a cső másik végén, vagyis filedes [0]. A fájl olvasásához és írásához szoktuk olvas() és ír() funkciókat.
2. példa
Ebben a példában meglátjuk, hogyan kommunikálnak a szülő és a gyermek folyamatai a cső segítségével.
// 2. példa.c#include
#include
#include
#include
#include
int main ()
int filedes [2], nbyte;
pid_t childpid;
char string [] = "Helló, világom!\ n ";
char readbuffer [80];
cső (filedes);
ha (((gyermeket = villa ()) == -1)
perror ("villa");
kilépés (1);
if (childpid == 0)
bezárás (filedes [0]); // A Child folyamatnak nincs szüksége a cső ezen végére
/ * "String" küldése a cső kimeneti oldalán keresztül * /
ír (filedes [1], string, (strlen (string) +1));
kilépés (0);
más
/ * A szülői folyamat lezárja a cső kimeneti oldalát * /
bezárás (filedes [1]); // A szülői folyamatnak nincs szüksége a cső ezen végére
/ * Olvasson be egy stringet a pipából * /
nbájt = olvasás (filedes [0], readbuffer, sizeof (readbuffer));
printf ("Olvasási karakterlánc:% s", readbuffer);
visszatérés (0);
Először egy csövet hoztak létre a csőfunkció használatával, majd egy gyermek folyamatot forkoltak el. Ezután a gyermekfolyamat bezárja az olvasási véget és a csőhöz ír. A szülő folyamat bezárja az írási véget, kiolvassa a csőből és megjeleníti azt. Itt az adatáramlás csak egy mód, amely gyermekről szülőre irányul.
Következtetés:
cső() egy erőteljes rendszerhívás Linux alatt. Ebben a cikkben csak egyirányú adatáramlást láthattunk, az egyik folyamat ír, a másik pedig olvas, két csövet létrehozva kétirányú adatáramlást is elérhetünk.
