అయితే, ప్రస్తుతం ఉన్న ప్రోగ్రామ్‌ని కొత్త దానితో మార్చడానికి exec () ఫంక్షన్ ఉపయోగించబడుతుంది. ప్రోగ్రామ్ లేదా ఫైల్ యొక్క కంటెంట్‌కు సవరణలు చేయడం ద్వారా ఈ భర్తీ జరుగుతుంది. కాబట్టి ఫోర్క్ మరియు ఎగ్జిక్యూట్ మధ్య అసమానత ఏమిటంటే ఫోర్క్ ఇప్పటికే ఉన్న ప్రాసెస్ నుండి కొత్త ప్రాసెస్‌ను సృష్టిస్తుంది, మరియు ఎక్సెక్ ఒక కొత్త ప్రోగ్రామ్‌ను క్రియేట్ చేయడం ద్వారా ఇప్పటికే ఉన్న ప్రోగ్రామ్‌ని భర్తీ చేయడానికి ఉపయోగించబడుతుంది.
ముందస్తు అవసరాలు
మీ లైనక్స్ సిస్టమ్‌లో ఏదైనా సి ప్రోగ్రామ్‌ను అమలు చేయడానికి, మేము దానిపై కొన్ని ముందస్తు అవసరాలను ఇన్స్టాల్ చేయాలి. సత్వరమార్గ పద్ధతి Ctrl+Alt+T ఉపయోగించి టెర్మినల్‌కు వెళ్లండి. ఇప్పుడు మ్యాన్ పేజీలను ఇన్స్టాల్ చేయడానికి కింది ఆదేశాలను వ్రాయండి.
$సుడోసముచితమైనదిఇన్స్టాల్manpages-dev
ఇది సంబంధిత అన్ని పేజీలను ఇన్స్టాల్ చేస్తుంది.
Linux లో ఒక ప్రోగ్రామ్‌ని అమలు చేయడానికి, మీరు ఒక కంపైలర్‌ని ఇన్స్టాల్ చేయాలి. అది కోడ్‌ను కంపైల్ చేయడానికి మరియు అమలు చేయడానికి ఉపయోగించబడుతుంది. ఈ ప్రయోజనం కోసం, మేము మా సిస్టమ్‌లో GCC రిపోజిటరీలను ఇన్స్టాల్ చేస్తాము.
$సుడోసముచితమైనదిఇన్స్టాల్జిసిసి 
C లో exec తో కోడింగ్
మేము Linux లో మ్యాన్ పేజీలను ఇన్స్టాల్ చేసినందున, exec కి సంబంధించిన వివరణను చూడటానికి మేము కింది ఆదేశాన్ని ఉపయోగిస్తాము. ప్రాథమిక నమూనా వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
వాక్యనిర్మాణం
కార్యనిర్వహణ(మార్గం పేరు/ఫైల్, argv);ఇక్కడ మేము unistd.h శీర్షికను ఉపయోగించాము ఎందుకంటే ఇందులో exec ఫంక్షన్ కుటుంబాల మొత్తం సమాచారం ఉంటుంది.
$మనిషి కార్యనిర్వహణ 
ఇప్పుడు పైన పేర్కొన్న చిత్రంలో, మీరు ఎగ్జిక్యూట్ రకాలను గమనించవచ్చు. ఇవి ఎగ్జిక్యూటివ్ ఫంక్షన్ల కుటుంబం. ప్రతి ఒక్కటి ఒకే బేస్, ఎక్సెక్‌ను అనుసరించి వేరే ఫంక్షన్ కోసం.
ఉదాహరణ: ఇప్పుడు, మరింత ముందుకు వెళితే, మేము ఒక ఉదాహరణ సహాయంతో exec యొక్క కార్యాచరణను వివరిస్తాము. మేము execv యొక్క పనిని ప్రదర్శించడానికి ఒక ఫంక్షన్ తీసుకుంటాము. ముందుగా, .c పొడిగింపుతో మేము రెండు ఫైల్‌లను సృష్టిస్తాము. వాటిని సృష్టించిన తర్వాత, మేము వాటిలో సంబంధిత కోడ్‌లను వ్రాస్తాము మరియు ఫలితాన్ని చూడటానికి వాటిని అమలు చేస్తాము.
నమూనా పేరు 4.4c ని పరిగణించండి. దయచేసి దానిని తెరిచి, క్రింది కోడ్‌ని ఉపయోగించండి. ఈ కోడ్‌లో, మేము దిగువ పేర్కొన్న నిర్దిష్ట పద్ధతిలో execv ని ఉపయోగించాము.
Execv(./నమూనా 4 కాపీ, ఆర్గ్స్);మొదటి భాగం కొత్త డైరెక్టరీ మార్గాన్ని కలిగి ఉంది మరియు రెండవ భాగం ఆర్గ్యుమెంట్‌ల శ్రేణిని మనం పాస్ చేసిన పరామితిగా చూపుతుంది.
నమూనా 4. సి
అన్నింటిలో మొదటిది, మేము ప్రస్తుత ప్రక్రియ ఐడిని ముద్రించాము. రెండవది, మేము రద్దు కోసం చివరలో NULL ఉన్న అక్షర శ్రేణిని సృష్టించాము. మూడవది మేము నమూనా 4 కాపీ ఫంక్షన్ అని పిలిచాము.
నమూనా 4 కాపీ.సిమేము exec ఫంక్షన్ () కి కాల్ చేసినప్పుడు, ప్రాసెస్ ఇమేజ్ మార్చబడుతుంది. దిగువ ఉదహరించిన చిత్రం క్రింద నమూనా 4 కాపీ.సి కోడ్‌ను చూపుతుంది.
ప్రస్తుత ప్రక్రియ ఐడిని పొందడానికి ఇక్కడ మేము ప్రింట్ స్టేట్‌మెంట్‌లను మాత్రమే ఉపయోగించాము.
కింది ఆదేశాలను ఉపయోగించి సంబంధిత కోడ్‌ల అవుట్పుట్ పొందవచ్చు.
$ GCC – o నమూనా 4 నమూనా 4..సి$ GCC –o నమూనా 4 కాపీ నమూనా 4 కాపీ.సి
$/నమూనా 4
మేము ఇంతకు ముందు వివరించినట్లుగా, GCC పదం కోడ్‌ను కంపైల్ చేయడానికి ఉపయోగించబడుతుంది మరియు కంపైల్ చేసిన తర్వాత, కోడ్ విజయవంతంగా అమలు చేయబడుతుంది.
చిత్రం ప్రకారం, నమూనా 4..సి ఫైల్ యొక్క PID మొదట చూపబడుతుంది, ఎందుకంటే ఇది exec కాల్‌కు ముందు ప్రకటించబడింది. Exec () ఫంక్షన్ అని పిలవబడిన తర్వాత, ప్రాసెస్ ఐడిని పొందడానికి getpid () ఉపయోగించిన చోట, ఫైల్ 4 నమూనా. కాపీ యొక్క ముద్రణ స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి.
సి లో ఫోర్క్ తో కోడింగ్
ఫోర్క్ () ఫంక్షన్ మాతృ ప్రక్రియ నుండి పిల్లల ప్రక్రియను సృష్టిస్తుంది. ఇది ఫోర్క్ సమాచారంతో సహా రెండు హెడర్‌లను కూడా కలిగి ఉంది.
వాక్యనిర్మాణం:
పిడ్_టి ఫోర్క్(శూన్యం);ఉపయోగంలో సహాయం కోసం మేము మ్యాన్ పేజీని ఉపయోగించవచ్చు
$మనిషిఫోర్క్ 
ఉదాహరణ: ఇప్పుడు నమూనా 3..సి ఫైల్‌ను సృష్టించడం ద్వారా ఒక ఉదాహరణను పరిశీలించండి. మేము ఫైల్ లోపల కోడ్‌ని నమోదు చేస్తాము. కోడ్ ప్రకారం, మేము ఫోర్క్ స్థితిని ఫోర్‌క్రాంక్‌గా సెట్ చేసాము.
నమూనా 3. సి
మేము షరతును వర్తింపజేయడానికి if-else ప్రకటనను ఉపయోగించాము. ఫోర్క్ () భావనను అర్థం చేసుకోవడంలో సహాయపడటానికి సాధారణ ముద్రణ ఆదేశాలు ఇక్కడ ప్రకటించబడ్డాయి. ఫోర్‌క్రాంక్ మొదట 0 మరియు తరువాత -1 గా ప్రకటించబడింది. ఫోర్క్ () తో, ఇప్పుడు రెండు ప్రక్రియలు ఏకకాలంలో పనిచేస్తున్నాయి. Exec ఉదాహరణలో పైన ఉపయోగించిన విధంగా, అదే కోడ్‌ని ఉపయోగించడం ద్వారా అవుట్పుట్ పొందవచ్చు.
$ GCC –o నమూనా 3. సి$/నమూనా 3
మాతృ ప్రక్రియ వేచి ఉన్నప్పుడు పిల్లల ప్రక్రియ తల్లిదండ్రుల కంటే ముందుగానే అమలు చేయబడిందని అవుట్పుట్ చూపుతుంది. అన్ని పిల్లల ప్రక్రియలలో ఒకటి ముగియకపోతే తప్ప పేరెంట్ ఫంక్షన్ వేచి ఉండటానికి కారణమవుతుందని వెయిట్ ఫంక్షన్ సూచిస్తుంది.
ఫోర్క్ మరియు ఎక్సెక్ సిస్టమ్ సమిష్టిగా కాల్ చేస్తుంది
ఇక్కడ మేము నమూనా 1. సి మరియు నమూనా 2. సి అనే రెండు ఫైల్‌లను తీసుకుంటాము. ముందుగా, sampl1.c ఫైల్‌ని తెరిచి, క్రింద జతచేయబడిన కోడ్‌ని చిత్రంలో వ్రాయండి. మేము ఇక్కడ ఫోర్క్ () సిస్టమ్-కాల్ ఉపయోగించాము; చైల్డ్ ప్రాసెస్ సృష్టించబడినప్పుడు, p కి 0 కేటాయించబడుతుంది. exec సిస్టమ్-కాల్‌ని ఉపయోగిస్తున్నప్పుడు, నమూనా 1. సి, నమూనా 2. సి తో భర్తీ చేయబడుతుంది.
నమూనా 1. సి
నమూనా 2. సి
పైన చర్చించిన ఉదాహరణల మాదిరిగానే, నమూనా 2 ఫైల్‌లో ప్రింట్ ఎఫ్ స్టేట్‌మెంట్‌లు ఉంటాయి. శాంపిల్ 1. సి లో, మొదటి ప్రింట్ కమాండ్ మొదట అమలు చేయబడుతుంది, తర్వాత ఫోర్క్ ఫంక్షన్ పిలువబడుతుంది, పి == 0 ఉన్నప్పుడు, పిల్లల భాగం ఎగ్జిక్యూట్ చేయబడుతుంది మరియు శాంపిల్ 2. సి ఫైల్ రన్ అవుతుంది. అవుట్పుట్ రెండు ఫైళ్లను కంపైల్ చేయడానికి GCC ని కలిగి ఉంటుంది. ఇక్కడ పేరెంట్ శాంపిల్ 1. సి ఐడి మరియు శాంపిల్ 2. సి ఐడి భిన్నంగా ఉంటాయి ఎందుకంటే వారు పేరెంట్ మరియు బిడ్డ.
ముగింపు
ఈ ఆర్టికల్లో, మేము ఫోర్క్ మరియు ఎగ్జిక్యూట్ రెండింటినీ విడివిడిగా మరియు సమిష్టిగా ఉపయోగించాము మరియు వాడుక మరియు భావనను సులభంగా అర్థం చేసుకున్నాము. ఈ ట్యుటోరియల్ మీ జ్ఞానాన్ని పెంపొందించడంలో యాక్సెస్ చేయడానికి దారితీసే తగినంత కంటెంట్‌ను కలిగి ఉందని నేను ఆశిస్తున్నాను.