ఐడిలను పొందడంలో ఉపయోగించే విధులు
ఇక్కడ రెండు రకాల ID లు ఉన్నాయి. ఒకటి ప్రాసెస్ పిఐడి ప్రస్తుత ఐడి. మరొకటి మాతృ ప్రక్రియ PPID యొక్క ఐడి అయితే. ఈ రెండు విధులు లైబ్రరీలో నిర్వచించబడిన అంతర్నిర్మిత విధులు. ఈ లైబ్రరీని ఉపయోగించకుండా కోడ్‌ను అమలు చేస్తున్నప్పుడు లోపం సంభవించవచ్చు మరియు అమలు చేయడం ఆగిపోతుంది.
C లో getpid () ఫంక్షన్
కొంత ప్రక్రియ ఏర్పడి మరియు నడుస్తున్నప్పుడు, దానికి ఒక ప్రత్యేకమైన id కేటాయించబడుతుంది. ఇది ప్రాసెస్ ఐడి. ఈ ఫంక్షన్ ప్రస్తుతం పిలవబడే ప్రాసెస్ యొక్క ఐడిని తిరిగి ఇవ్వడంలో సహాయపడుతుంది.
C లో getppid () ఫంక్షన్
మాతృ ప్రక్రియ/ఫంక్షన్ ప్రక్రియను తిరిగి ఇవ్వడంలో ఈ ఐడి ఉపయోగపడుతుంది.
ఉదాహరణ 1
C భాషలో ప్రక్రియలో PID యొక్క ఉదాహరణను అర్థం చేసుకోవడానికి. మీకు రెండు టూల్స్ అవసరం: ఏదైనా టెక్స్ట్ ఎడిటర్ మరియు లైనక్స్ టెర్మినల్, దీనిలో మీరు ఆదేశాలను అమలు చేయాలి. ఏదైనా టెక్స్ట్ ఎడిటర్‌లో ఫైల్‌ను సృష్టించండి. కోడ్ C భాషలో వ్రాయబడినందున మేము కోడ్ 1..సి అనే ఫైల్ పేరును సృష్టించాము, కనుక దీనిని .c పొడిగింపుతో సేవ్ చేయాలి.
మేము ఒకే లైబ్రరీని జోడించాము. అప్పుడు ఇక్కడ ప్రధాన కార్యక్రమం ప్రారంభమవుతుంది. ప్రధాన ప్రోగ్రామ్‌లో, మేము అంతర్నిర్మిత ఫంక్షన్‌ను getpid () అని పిలుస్తాము; ప్రస్తుత ప్రక్రియ ఐడిని పొందడానికి. మరియు ఒక వేరియబుల్ ప్రవేశపెట్టబడింది మరియు కేటాయించబడింది. కాబట్టి PID () ఫంక్షన్ విలువ ఈ వేరియబుల్‌లో స్టోర్ చేయబడుతుంది, అప్పుడు మేము ఈ వేరియబుల్ ఉపయోగించి విలువ ప్రింట్ తీసుకుంటాము.
ఇప్పుడు మేము ఈ ఫైల్‌లోని విషయాలను Linux టెర్మినల్‌లో అమలు చేయాలనుకుంటున్నాము. కోడ్ అవసరం ముందుగా సంకలనం చేయబడి, ఆపై అమలు చేయాలి. సంకలనం కోసం, GCC ఉపయోగించబడుతుంది. మీ సిస్టమ్‌లో GCC లేనట్లయితే, మీరు దానిని సుడో కమాండ్ ఉపయోగించి ముందుగా ఇన్‌స్టాల్ చేయాలి.
ఇప్పుడు వ్రాసిన కోడ్‌ని కంపైల్ చేయండి. కింది అనుబంధ ఆదేశాన్ని ఉపయోగించి దీనిని సాధించవచ్చు.
$ GCC –o కోడ్ 1 కోడ్ 1. సి 
అయితే –o కమాండ్‌లోని సేవ్ ఫైల్‌ను తెరవడానికి ఉపయోగించబడుతుంది. తరువాత –o తరువాత, మేము ఫైల్ పేరు వ్రాస్తాము.
సంకలనం తరువాత, ఆదేశాన్ని అమలు చేయండి.
$ ./ కోడ్ 1 
పై చిత్రం ఫంక్షన్ యొక్క ప్రాసెస్ ఐడిని చూపుతుంది.
ఉదాహరణ 2
మునుపటి ఉదాహరణలో, మేము PID ని ఉపయోగిస్తాము. కానీ ఈ ఉదాహరణలో, PID మరియు PPID రెండూ ఉపయోగించబడతాయి. ఈ ఫంక్షన్‌కి సోర్స్ కోడ్ దాదాపు మునుపటి మాదిరిగానే ఉంటుంది. ఒక ID ని మరొక అదనంగా చేర్చడం మాత్రమే.
ప్రాసెస్ ID ల ద్వారా కేటాయించబడిన ప్రధాన ప్రోగ్రామ్‌లో రెండు వేరియబుల్స్ ఉన్న ఫైల్‌ను పరిగణించండి. ఒకటి ప్రస్తుత ప్రక్రియ, మరొకటి మాతృ ప్రక్రియ. మొదటి ఉదాహరణ మాదిరిగానే, రెండు ఐడీలను వాటి వేరియబుల్స్ ద్వారా ప్రింట్ చేయండి.
Int pid_t = getpid ();Int ppid_t = getppid ();
ఈ రెండు మొత్తం కోడ్ యొక్క ప్రధాన విధులు. ఇప్పుడు, ఫైల్ క్రియేషన్ తరువాత, తదుపరి దశ ఫైల్‌ను కంపైల్ చేసి రన్ చేయడం. కమాండ్‌లో GCC ని ఉపయోగించి కంపైల్ చేయండి. సంకలనం చేసిన తర్వాత, దానిని ఉబుంటు టెర్మినల్‌లో అమలు చేయండి.
$ GCC –o కోడ్ 1 కోడ్ 1. సి$ ./ కోడ్ 1
ముందుగా ప్రాసెస్ ఐడి ప్రదర్శించబడిందని, ఆపై పేరెంట్ ప్రాసెస్ ఐడి ప్రదర్శించబడుతుందని అవుట్‌పుట్ చూపుతుంది.
ఉదాహరణ 3
అన్ని ప్రక్రియలు సమాంతరంగా అమలు మరియు అమలు. తల్లిదండ్రులు మరియు పిల్లల ప్రక్రియలు మిగిలిన అన్ని లైన్లను సమిష్టిగా అమలు చేస్తాయి. రెండూ ఒకేసారి ఫలితాలను ఇస్తాయి. కానీ C కోడ్‌లోని ఫోర్క్‌ను ఉపయోగించడం ద్వారా, ఈ ఫంక్షన్ 0 కంటే తక్కువ విలువను అందిస్తే, ఫంక్షన్ కాల్ నిలిపివేయబడిందని అర్థం.
సంబంధిత శీర్షికలో రెండు లైబ్రరీలను కలిగి ఉన్న కొత్త ఫైల్‌ని పరిగణించండి. ఇక్కడ ఒక షరతు ఉపయోగించబడుతుంది, దీనిలో if-else స్టేట్‌మెంట్‌ను మేము ఉపయోగించాము. ప్రధాన ప్రోగ్రామ్‌లో, ఫోర్క్ విలువ –ive విలువలో ఉంటే, ప్రాసెస్ యొక్క ఐడి విఫలమైందని మరియు అది పొందబడదని సందేశాన్ని ప్రదర్శిస్తుందని పేర్కొనబడింది. పరిస్థితి తప్పు అయితే, కంపైలర్ పరిస్థితి యొక్క ఇతర భాగానికి తరలించబడుతుంది. ఈ భాగంలో, ప్రాసెస్ ఐడి పొందబడింది, అప్పుడు మేము ఈ ప్రాసెస్ ఐడిని ప్రదర్శిస్తాము మరియు ప్రాసెస్ ఐడి పొందిన సందేశాన్ని ప్రదర్శిస్తాము. ఇక్కడ మేము సోర్స్ కోడ్ యొక్క if-else స్టేట్‌మెంట్‌ను కోట్ చేస్తాము.
ఇప్పుడు మళ్లీ, కోడ్‌ను కంపైల్ చేసి, ఆపై దాన్ని అమలు చేయండి.
./ కోడ్ 2 
ఇతర భాగం అమలు చేయబడిందని మరియు ప్రాసెస్ ఐడిని ముద్రించి, ఆపై PID సందేశాన్ని ప్రదర్శిస్తుందని అవుట్‌పుట్ చూపుతుంది.
ఉదాహరణ 4
ఇదే భావనను వివరించడానికి ఇది మరొక ఉదాహరణ. ఫోర్క్ () ఫంక్షన్ రెండు వేర్వేరు విలువలను అందిస్తుంది. పిల్లల ప్రక్రియ విషయంలో, విలువ 0, ఇది తిరిగి ఇవ్వబడుతుంది. అదే సమయంలో, పేరెంట్ ప్రాసెస్ విషయంలో విలువ కొత్త పిల్లల ప్రాసెస్ ఐడి.
ఈ ఉదాహరణలో, అదే if_else పరిస్థితి ఉపయోగించబడుతుంది. కానీ ఇక్కడ, రెండు షరతులు వర్తింపజేయబడ్డాయి. PID ని సున్నా కంటే తక్కువ మరియు మరొకటి సున్నాకి సమానం. PID సున్నా కంటే తక్కువగా ఉంటే, అది దోష సందేశాన్ని చూపుతుంది. PID సున్నాకి సమానం అయితే, అది పిల్లల ప్రక్రియ అని అర్థం, మరియు ఇతర భాగం PID సున్నా కంటే ఎక్కువ ఉంటే, అది మాతృ ప్రక్రియ అని చూపిస్తుంది.
ఇప్పుడు కోడ్‌ను కంపైల్ చేసి అమలు చేయండి.
$ gcc –o కోడ్ 3 కోడ్ 3.సి$./కోడ్ 3
అవుట్‌పుట్ నుండి, మిగిలిన భాగం ముందుగా ముద్రించబడిందని మనం అర్థం చేసుకోవచ్చు ప్రాసెస్ ID 0 కంటే ఎక్కువ.
ఉదాహరణ 5
సరే, ఈ ఫంక్షన్ యొక్క పనిని వివరించడానికి పైన వివరించిన అన్ని కోడ్‌లను సంగ్రహించడానికి మేము ప్రయత్నించిన చివరి ఉదాహరణ ఇది. గెట్‌పిడ్ () ఫంక్షన్‌లను ఉపయోగించడానికి మేము ఫోర్క్ () ఫంక్షన్‌లతో లూప్‌లను కూడా ఉపయోగించవచ్చు. మేము అనేక పిల్లల ప్రక్రియలను సృష్టించడానికి లూప్‌లను ఉపయోగించవచ్చు. ఇక్కడ మనం లూప్‌లో 3 విలువను ఉపయోగించాలి.
మళ్లీ మనం కోడ్‌లోని షరతులతో కూడిన స్టేట్‌మెంట్‌ని ఉపయోగించాలి. ఫోర్ లూప్ ఒకటి నుండి మొదలవుతుంది మరియు 3 వరకు పునరావృతం అవుతుందిrdమలుపు.
ఇప్పుడు ఫైల్‌ను సేవ్ చేసి దాన్ని అమలు చేయండి. ఒకే కమాండ్‌లో మాత్రమే కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి మరొక సాధారణ పద్ధతి ఉంది. అంటే.
$ GCC కోడ్‌లు 5.c –o s & ./code5ఇప్పుడు కోడ్ అవుట్‌పుట్ వైపు కదులుతోంది. అన్ని పిల్లల ప్రక్రియలలో మాతృ ప్రక్రియ యొక్క ఐడి ఒకేలా ఉంటుంది. దీని అర్థం ఈ ప్రక్రియలన్నీ ఒక పేరెంట్‌కు చెందినవి. లూప్ 3 కి పరిమితం చేయబడినందున ఈ ప్రక్రియలు ఒకదాని తర్వాత ఒకటి అమలు చేయబడతాయి. కేవలం 3 పునరావృత్తులు మాత్రమే చేయబడతాయి.
ముగింపు
ఈ వ్యాసం ప్రాథమిక జ్ఞానాన్ని కలిగి ఉంది మరియు Linux ఆదేశాలలో getPID () ఫంక్షన్ పని చేస్తుంది. ఈ ఫంక్షన్ ద్వారా ప్రతి ప్రక్రియకు ప్రత్యేకమైన id కేటాయించబడుతుంది.