A cső a folyamatok közötti kommunikáció közege. Az egyik folyamat adatokat ír a csőbe, a másik pedig a csőből. Ebben a cikkben látni fogjuk, hogyan használják a pipe () függvényt a koncepció megvalósítására C nyelven.
A Pipe -ről
A csőben az adatok FIFO sorrendben kerülnek karbantartásra, ami azt jelenti, hogy adatokat írnak a cső egyik végébe egymás után, és adatokat olvasnak le a cső másik végéből ugyanabban a sorrendben.
Ha bármely folyamat olvas a csőből, de más folyamat még nem írt a csőbe, akkor az olvasás visszaadja a fájl végét. Ha egy folyamat írni szeretne egy csőre, de nincs más folyamat, amely a csőhöz van csatlakoztatva olvasáshoz, akkor ez hibaállapot, és a cső SIGPIPE jelet generál.
Fejléc fájl
#befoglalniSzintaxis
intpipa(intfájlok[2])
Érvek
Ez a függvény egyetlen argumentumot, két egész számból álló tömböt ( fájlok ). filedes [0] a csőből történő olvasásra szolgál, és fájlok [1] a csőbe írásra használják. A folyamatnak, amely ki akar olvasni a csőből, le kell zárnia fájlok [1], és a folyamatnak, amely írni akar a csőbe, le kell zárnia filedes [0] . Ha a cső szükségtelen végei nincsenek kifejezetten lezárva, akkor a fájlvég (EOF) soha nem kerül visszaadásra.
Visszaadja az értékeket
A sikerről a pipa() 0 -t ad vissza, hiba esetén a függvény -1 -et ad vissza.
Képileg képviselhetjük a pipa() funkció a következő:
Az alábbiakban bemutatunk néhány példát, amelyek a pipe funkció C nyelvű használatát mutatják be.
1. példa
Ebben a példában látni fogjuk, hogyan működik a csőfunkció. Bár egy cső használata egyetlen folyamatban nem túl hasznos, de kapunk egy ötletet.
// Példa1.c#befoglalni
#befoglalni
#befoglalni
#befoglalni
intfő-()
{
intn;
intfájlok[2];
charpuffer[1025];
char *üzenet= 'Helló Világ!';
pipa(fájlok);
ír(fájlok[1],üzenet, strlen (üzenet));
ha ((n=olvas(fájlok[0],puffer, 1024 ) ) > = 0) {
puffer[n] = 0; // fejezze be a karakterláncot
printf (' %d bájt olvasása a csőből:'%s' n',n,puffer);
}
más
tévedés ('olvas');
kijárat (0);
}
Itt először egy csövet hoztunk létre pipa() függvényt, majd a segítségével a csőbe írva elefántcsont [1] vége. Ezután az adatokat a cső másik végén, azaz filedes [0] . A fájl olvasásához és írásához szoktuk olvas() és ír() funkciókat.
Példa2
Ebben a példában látni fogjuk, hogyan kommunikálnak a szülő és a gyermek folyamatai a cső segítségével.
// Példa2.c#befoglalni
#befoglalni
#befoglalni
#befoglalni
#befoglalni
intfő-()
{
intfájlok[2],nbyte;
pid_t gyerekes;
charhúr[] = 'Helló Világ! n';
charolvasó puffer[80];
pipa(fájlok);
ha((gyerekes=Villa()) == -1)
{
tévedés ('Villa');
kijárat (1);
}
ha(gyerekes== 0)
{
Bezárás(fájlok[0]);// A gyermekfolyamatnak nincs szüksége a cső ezen végére
/ * „String” küldése a cső kimeneti oldalán keresztül */
ír(fájlok[1],húr, ( strlen (húr)+1));
kijárat (0);
}
más
{
/ * A szülői folyamat bezárja a cső kimeneti oldalát */
Bezárás(fájlok[1]);// A szülői folyamatnak nincs szüksége a cső ezen végére
/ * Olvasson be egy karakterláncot a csőből */
nbyte=olvas(fájlok[0],olvasó puffer, mérete(olvasó puffer));
printf ('Karakterlánc olvasása: %s',olvasó puffer);
}
Visszatérés(0);
}
Először egy csövet hoztak létre a cső funkcióval, majd egy gyermek folyamatot elágaztak. Ezután a gyermekfolyamat bezárja az olvasás végét és ír a csőbe. A szülői folyamat bezárja az írás végét, és olvas a csőből, és megjeleníti azt. Itt az adatáramlás csak egy módja a gyermeknek a szülőnek.
Következtetés:
pipa() egy erőteljes rendszerhívás a Linuxban. Ebben a cikkben csak egyirányú adatáramlást láttunk, egy folyamat ír, és egy másik folyamat olvas, két cső létrehozásával kétirányú adatáramlást is elérhetünk.