చిత్రం 1: ప్రాథమిక ఫోర్క్ () వర్క్‌ఫ్లో
ఈ వ్యాసంలో, C. లో పిల్లల ప్రక్రియలను సృష్టించడానికి ఫోర్క్ () సిస్టమ్ కాల్‌ను ఎలా ఉపయోగించాలో నేను మీకు చూపించబోతున్నాను, కాబట్టి ప్రారంభిద్దాం.
ఫోర్క్ () సింటాక్స్ మరియు రిటర్న్ వాల్యూ:
ఫోర్క్ () సిస్టమ్ ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
పిడ్_టి ఫోర్క్(శూన్యం);
ఫోర్క్ () సిస్టమ్ ఫంక్షన్ ఏ వాదనను అంగీకరించదు. ఇది రకం యొక్క పూర్ణాంకాన్ని అందిస్తుంది pid_t .
విజయవంతం అయినప్పుడు, ఫోర్క్ () పిల్లల ప్రక్రియ యొక్క PID ని 0. కంటే ఎక్కువ అందిస్తుంది, పిల్లల ప్రక్రియ లోపల, రిటర్న్ విలువ 0. ఫోర్క్ () విఫలమైతే, అది -1 కి తిరిగి వస్తుంది.
సాధారణ ఫోర్క్ () ఉదాహరణ:
ఒక సాధారణ ఫోర్క్ () ఉదాహరణ క్రింద ఇవ్వబడింది:
#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన(శూన్యం) {
pid_t పిడ్=ఫోర్క్();
ఉంటే(పిడ్== 0) {
printf ('చైల్డ్ => PPID: %d PID: %d n',getppid(),గెట్‌పిడ్());
బయటకి దారి (EXIT_SUCCESS);
}
లేకపోతే ఉంటే(పిడ్> 0) {
printf ('పేరెంట్ => PID: %d n',గెట్‌పిడ్());
printf (పిల్లల ప్రక్రియ పూర్తయ్యే వరకు వేచి ఉంది. n');
వేచి ఉండండి(శూన్య);
printf ('పిల్లల ప్రక్రియ పూర్తయింది. n');
}
లేకపోతే {
printf ('పిల్లల ప్రక్రియను సృష్టించడం సాధ్యపడలేదు. n');
}
తిరిగిEXIT_SUCCESS;
}
ఇక్కడ, ప్రధాన/మాతృ ప్రక్రియ నుండి పిల్లల ప్రక్రియను సృష్టించడానికి నేను ఫోర్క్ () ఉపయోగించాను. అప్పుడు, నేను పిల్లల మరియు మాతృ ప్రక్రియ నుండి PID (ప్రాసెస్ ID) మరియు PPID (పేరెంట్ ప్రాసెస్ ID) ముద్రించాను. మాతృ ప్రక్రియలో వెయిట్ (NULL) అనేది పిల్లల ప్రక్రియ పూర్తయ్యే వరకు వేచి ఉండటానికి ఉపయోగించబడుతుంది. పిల్లల ప్రక్రియలో, పిల్లల ప్రక్రియను పూర్తి చేయడానికి నిష్క్రమణ () ఉపయోగించబడుతుంది. మీరు గమనిస్తే, మాతృ ప్రక్రియ యొక్క PID అనేది పిల్లల ప్రక్రియ యొక్క PPID. కాబట్టి, పిల్లల ప్రక్రియ 24738 మాతృ ప్రక్రియకు చెందినది 24731 .
మీ ప్రోగ్రామ్‌ను మరింత మాడ్యులర్ చేయడానికి మీరు ఫంక్షన్‌లను కూడా ఉపయోగించవచ్చు. ఇక్కడ, నేను ఉపయోగించాను ప్రాసెస్ టాస్క్ () మరియు పేరెంట్ టాస్క్ () పిల్లల మరియు మాతృ ప్రక్రియల కోసం వరుసగా విధులు. వాస్తవానికి ఫోర్క్ () ఎలా ఉపయోగించబడుతుంది.
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
శూన్యంచైల్డ్ టాస్క్() {
printf ('హలో వరల్డ్ n');
}
శూన్యంపేరెంట్ టాస్క్() {
printf ('ప్రధాన పని. n');
}
intప్రధాన(శూన్యం) {
pid_t పిడ్=ఫోర్క్();
ఉంటే(పిడ్== 0) {
చైల్డ్ టాస్క్();
బయటకి దారి (EXIT_SUCCESS);
}
లేకపోతే ఉంటే(పిడ్> 0) {
వేచి ఉండండి(శూన్య);
పేరెంట్ టాస్క్();
}
లేకపోతే {
printf ('పిల్లల ప్రక్రియను సృష్టించడం సాధ్యపడలేదు.');
}
తిరిగిEXIT_SUCCESS;
}
పై ప్రోగ్రామ్ యొక్క అవుట్‌పుట్:
ఫోర్క్ () మరియు లూప్ ఉపయోగించి బహుళ చైల్డ్ ప్రక్రియలను అమలు చేయడం:
మీకు అవసరమైనన్ని పిల్లల ప్రక్రియలను సృష్టించడానికి మీరు లూప్‌ని కూడా ఉపయోగించవచ్చు. దిగువ ఉదాహరణలో, నేను లూప్ కోసం ఉపయోగించి 5 పిల్లల ప్రక్రియలను సృష్టించాను. నేను పిల్లల ప్రక్రియల నుండి PID మరియు PPID లను కూడా ముద్రించాను.
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
intప్రధాన(శూన్యం) {
కోసం(inti= 1;i<= 5;i++) {
pid_t పిడ్=ఫోర్క్();
ఉంటే(పిడ్== 0) {
printf ('పిల్లల ప్రక్రియ => PPID =%d, PID =%d n',getppid(),గెట్‌పిడ్());
బయటకి దారి (0);
}
లేకపోతే {
printf ('పేరెంట్ ప్రాసెస్ => PID =%d n',గెట్‌పిడ్());
printf (పిల్లల ప్రక్రియలు పూర్తయ్యే వరకు వేచి ఉంది ... n');
వేచి ఉండండి(శూన్య);
printf ('పిల్లల ప్రక్రియ పూర్తయింది. n');
}
}
తిరిగిEXIT_SUCCESS;
}
మీరు చూడగలిగినట్లుగా, అన్ని పిల్లల ప్రక్రియలలో తల్లిదండ్రుల ప్రాసెస్ ID ఒకే విధంగా ఉంటుంది. కాబట్టి, వారందరూ ఒకే తల్లిదండ్రులకు చెందినవారు. వారు సరళ పద్ధతిలో కూడా అమలు చేస్తారు. ఒకదాని తరువాత మరొకటి. పిల్లల ప్రక్రియలను నియంత్రించడం ఒక అధునాతన పని. మీరు Linux సిస్టమ్ ప్రోగ్రామింగ్ గురించి మరియు అది ఎలా పనిచేస్తుందనే దాని గురించి మరింత తెలుసుకుంటే, మీకు నచ్చిన విధంగా ఈ ప్రక్రియల ప్రవాహాన్ని నియంత్రించవచ్చు.
నిజ జీవిత ఉదాహరణ:
ఎమ్‌డి 5, షా 256 మొదలైన విభిన్న సంక్లిష్ట గణిత గణనలకు చాలా ప్రాసెసింగ్ శక్తి అవసరం. ప్రధాన ప్రోగ్రామ్ వలె అదే ప్రక్రియలో కంప్యూటింగ్ చేయడానికి బదులుగా, మీరు పిల్లల ప్రక్రియపై హాష్‌ను లెక్కించవచ్చు మరియు హాష్‌ను ప్రధాన ప్రక్రియకు తిరిగి ఇవ్వవచ్చు.
కింది ఉదాహరణలో, నేను పిల్లల ప్రక్రియలో 4 అంకెల PIN కోడ్‌ని జనరేట్ చేసాను మరియు దానిని పేరెంట్ ప్రాసెస్, ప్రధాన ప్రోగ్రామ్‌కు పంపుతాను. అప్పుడు, నేను పిన్ కోడ్‌ను అక్కడ నుండి ముద్రించాను.
#చేర్చండి#చేర్చండి
#చేర్చండి
#చేర్చండి
#చేర్చండి
intgetPIN() {
// PPID మరియు PID ని విత్తనంగా ఉపయోగించండి
చిరాకు (గెట్‌పిడ్() +getppid());
intరహస్య= 1000 + వరుస () % 9000;
తిరిగిరహస్య;
}
intప్రధాన(శూన్యం) {
intఎఫ్ డి[2];
పైపు(ఎఫ్ డి);
pid_t పిడ్=ఫోర్క్();
ఉంటే(పిడ్> 0) {
దగ్గరగా(0);
దగ్గరగా(ఎఫ్ డి[1]);
తర్వాత(ఎఫ్ డి[0]);
intరహస్య సంఖ్య;
పరిమాణం_టిరీడ్ బైట్స్=చదవండి(ఎఫ్ డి[0], &రహస్య సంఖ్య, పరిమాణం(రహస్య సంఖ్య));
printf ('పిన్ కోసం వేచి ఉంది ... n');
వేచి ఉండండి(శూన్య);
printf ('బైట్‌లు చదవండి: %ld n',రీడ్ బైట్స్);
printf ('పిన్: %d n',రహస్య సంఖ్య);
}
లేకపోతే ఉంటే(పిడ్== 0) {
దగ్గరగా(1);
దగ్గరగా(ఎఫ్ డి[0]);
తర్వాత(ఎఫ్ డి[1]);
intరహస్య=getPIN();
వ్రాయడానికి(ఎఫ్ డి[1], &రహస్య, పరిమాణం(రహస్య));
బయటకి దారి (EXIT_SUCCESS);
}
తిరిగిEXIT_SUCCESS;
}
మీరు చూడగలిగినట్లుగా, నేను ప్రోగ్రామ్‌ను అమలు చేస్తున్న ప్రతిసారీ, నేను వేరే 4 అంకెల PIN కోడ్‌ను పొందుతాను.
కాబట్టి, ప్రాథమికంగా మీరు లైనక్స్‌లో ఫోర్క్ () సిస్టమ్ కాల్‌ను ఎలా ఉపయోగిస్తున్నారు. ఈ కథనాన్ని చదివినందుకు ధన్యవాదాలు.