ప్రక్రియల మధ్య కమ్యూనికేషన్ కోసం ఒక పైప్ ఒక మాధ్యమం. ఒక ప్రక్రియ పైపుకు డేటాను వ్రాస్తుంది, మరొక ప్రక్రియ పైప్ నుండి డేటాను చదువుతుంది. ఈ వ్యాసంలో, C భాషను ఉపయోగించి భావనను అమలు చేయడానికి పైప్ () ఫంక్షన్ ఎలా ఉపయోగించబడుతుందో చూద్దాం.
పైప్ గురించి
పైపులో, డేటా ఒక FIFO క్రమంలో నిర్వహించబడుతుంది, అంటే పైపు యొక్క ఒక చివర డేటాను వరుసగా వ్రాయడం మరియు పైపు యొక్క మరొక చివర నుండి డేటాను ఒకే వరుస క్రమంలో చదవడం.
ఒకవేళ పైప్ నుండి ఏదైనా ప్రక్రియ చదివినా, ఇంకా ఏ ఇతర ప్రక్రియ కూడా పైపుకు వ్రాయబడలేదు, అప్పుడు ఎండ్ ఆఫ్ ఫైల్ రిటర్న్స్ చదవండి. ఒక ప్రక్రియ ఒక పైపుకి వ్రాయాలనుకుంటే, కానీ చదవడానికి పైపుకు ఏ ఇతర ప్రక్రియ జతచేయబడకపోతే, ఇది ఒక దోష పరిస్థితి, మరియు పైపు SIGPIPE సిగ్నల్‌ని ఉత్పత్తి చేస్తుంది.
హెడర్ ఫైల్
#చేర్చండివాక్యనిర్మాణం
intపైపు(intదాఖలు చేసింది[2])
వాదనలు
ఈ ఫంక్షన్ ఒకే ఆర్గ్యుమెంట్ తీసుకుంటుంది, రెండు పూర్ణాంకాల శ్రేణి ( దాఖలు చేసింది ). దాఖలు [0] పైపు నుండి చదవడానికి ఉపయోగిస్తారు, మరియు దాఖలు [1] పైపుకు రాయడానికి ఉపయోగిస్తారు. పైప్ నుండి చదవాలనుకునే ప్రక్రియ మూసివేయబడాలి దాఖలు [1], మరియు పైపుకు వ్రాయాలనుకునే ప్రక్రియ మూసివేయబడాలి దాఖలు [0] . పైపు యొక్క అనవసరమైన చివరలను స్పష్టంగా మూసివేయకపోతే, ఎండ్-ఆఫ్-ఫైల్ (EOF) ఎప్పటికీ తిరిగి ఇవ్వబడదు.
తిరిగి విలువలు
విజయంపై, ది పైపు () ఫంక్షన్ రిటర్న్స్ -1, ఫెయిల్యూర్ కోసం 0 రిటర్న్స్ ఇస్తుంది.
చిత్రపరంగా, మేము ప్రాతినిధ్యం వహిస్తాము పైపు () కింది విధంగా ఫంక్షన్:
C భాషలో పైప్ ఫంక్షన్‌ను ఎలా ఉపయోగించాలో వివరించే కొన్ని ఉదాహరణలు క్రింద ఉన్నాయి.
ఉదాహరణ 1
ఈ ఉదాహరణలో, పైప్ ఫంక్షన్ ఎలా పని చేస్తుందో చూద్దాం. ఒకే ప్రక్రియలో పైప్‌ని ఉపయోగించడం చాలా ఉపయోగకరం కానప్పటికీ, మాకు ఒక ఆలోచన వస్తుంది.
// ఉదాహరణ 1. సి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన()
{
intఎన్;
intదాఖలు చేసింది[2];
చార్బఫర్[1025];
చార్ *సందేశం= 'హలో, వరల్డ్!';
పైపు(దాఖలు చేసింది);
వ్రాయడానికి(దాఖలు చేసింది[1],సందేశం, strlen (సందేశం));
ఉంటే ((ఎన్=చదవండి(దాఖలు చేసింది[0],బఫర్, 1024 ) ) > = 0) {
బఫర్[ఎన్] = 0; // స్ట్రింగ్‌ను ముగించండి
printf ('పైపు నుండి %d బైట్‌లను చదవండి:'%లు' n',ఎన్,బఫర్);
}
లేకపోతే
పెరర్ ('చదవండి');
బయటకి దారి (0);
}
ఇక్కడ మేము మొదట పైపును ఉపయోగించి సృష్టించాము పైపు () ఫంక్షన్ ఉపయోగించి పైప్‌కు వ్రాస్తారు ఐవరీ [1] ముగింపు. అప్పుడు, పైపు యొక్క మరొక చివరను ఉపయోగించి డేటా చదవబడుతుంది, అంటే దాఖలు [0] . ఫైల్‌కు చదవడం మరియు వ్రాయడం కోసం, మేము ఉపయోగించాము చదవండి() మరియు వ్రాయడానికి() విధులు.
ఉదాహరణ 2
ఈ ఉదాహరణలో, పైప్ ఉపయోగించి తల్లిదండ్రులు మరియు పిల్లల ప్రక్రియలు ఎలా కమ్యూనికేట్ చేస్తాయో చూద్దాం.
// ఉదాహరణ 2. సి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన()
{
intదాఖలు చేసింది[2],nbytes;
pid_t చైల్డ్పిడ్;
చార్స్ట్రింగ్[] = 'హలో, ప్రపంచం! n';
చార్రీడ్ బఫర్[80];
పైపు(దాఖలు చేసింది);
ఉంటే((చైల్డ్పిడ్=ఫోర్క్()) == -1)
{
పెరర్ ('ఫోర్క్');
బయటకి దారి (1);
}
ఉంటే(చైల్డ్పిడ్== 0)
{
దగ్గరగా(దాఖలు చేసింది[0]);// పిల్లల ప్రక్రియకు పైపు ఈ చివర అవసరం లేదు
/ * పైపు అవుట్‌పుట్ సైడ్ ద్వారా 'స్ట్రింగ్' పంపండి */
వ్రాయడానికి(దాఖలు చేసింది[1],స్ట్రింగ్, ( strlen (స్ట్రింగ్)+1));
బయటకి దారి (0);
}
లేకపోతే
{
/ * తల్లిదండ్రుల ప్రక్రియ పైపు అవుట్‌పుట్ సైడ్‌ను మూసివేస్తుంది */
దగ్గరగా(దాఖలు చేసింది[1]);// తల్లిదండ్రుల ప్రక్రియకు పైపు ఈ ముగింపు అవసరం లేదు
/ * పైప్ నుండి స్ట్రింగ్‌లో చదవండి */
nbytes=చదవండి(దాఖలు చేసింది[0],రీడ్ బఫర్, పరిమాణం(రీడ్ బఫర్));
printf ('స్ట్రింగ్ చదవండి: %s',రీడ్ బఫర్);
}
తిరిగి(0);
}
మొదట, పైప్ ఫంక్షన్ ఉపయోగించి ఒక పైపు సృష్టించబడింది, తరువాత పిల్లల ప్రక్రియ ఫోర్క్ చేయబడింది. అప్పుడు, పిల్లల ప్రక్రియ రీడ్ ఎండ్‌ను మూసివేసి పైపుకు వ్రాస్తుంది. మాతృ ప్రక్రియ వ్రాత ముగింపును మూసివేసి పైపు నుండి చదివి ప్రదర్శిస్తుంది. ఇక్కడ డేటా ప్రవాహం అనేది పిల్లల నుండి తల్లిదండ్రుల వరకు ఉండే ఒక మార్గం.
ముగింపు:
పైపు () Linux లో శక్తివంతమైన సిస్టమ్ కాల్. ఈ వ్యాసంలో, మేము ఒక-మార్గం డేటా ప్రవాహాన్ని మాత్రమే చూశాము, ఒక ప్రక్రియ వ్రాస్తుంది, మరియు మరొక ప్రక్రియ చదువుతుంది, రెండు పైపులను సృష్టించడం ద్వారా మనం ద్వి-దిశ డేటా ప్రవాహాన్ని కూడా సాధించవచ్చు.