படம் 1: அடிப்படை முட்கரண்டி () பணிப்பாய்வு
இந்த கட்டுரையில், சி இல் குழந்தை செயல்முறைகளை உருவாக்க ஃபோர்க் () சிஸ்டம் அழைப்பை எவ்வாறு பயன்படுத்துவது என்பதை நான் உங்களுக்கு காண்பிக்கப் போகிறேன். எனவே, தொடங்குவோம்.
முட்கரண்டி () தொடரியல் மற்றும் திரும்பும் மதிப்பு:
ஃபோர்க் () சிஸ்டம் செயல்பாட்டின் தொடரியல் பின்வருமாறு:
pid_t முட்கரண்டி(வெற்றிடம்);
ஃபோர்க் () கணினி செயல்பாடு எந்த வாதத்தையும் ஏற்காது. இது வகை முழு எண்ணை வழங்குகிறது pid_t .
வெற்றியில், ஃபோர்க் () குழந்தை செயல்முறையின் PID ஐ விட அதிகமாக உள்ளது. இது குழந்தை செயல்பாட்டின் உள்ளே, திரும்பும் மதிப்பு 0. ஆகும்.
எளிய முட்கரண்டி () உதாரணம்:
ஒரு எளிய முட்கரண்டி () உதாரணம் கீழே கொடுக்கப்பட்டுள்ளது:
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய(வெற்றிடம்) {
pid_t pid=முள் கரண்டி();
என்றால்(பிட்== 0) {
printf ('குழந்தை => PPID: %d PID: %d n',getppid(),getpid());
வெளியேறு (EXIT_SUCCESS);
}
வேறு என்றால்(பிட்> 0) {
printf ('பெற்றோர் => PID: %d n',getpid());
printf (குழந்தை செயல்முறை முடிவடையும் வரை காத்திருக்கிறது. n');
காத்திரு(ஏதுமில்லை);
printf ('குழந்தை செயல்முறை முடிந்தது. n');
}
வேறு {
printf ('குழந்தை செயல்முறையை உருவாக்க முடியவில்லை. n');
}
திரும்பEXIT_SUCCESS;
}
இங்கே, முக்கிய/பெற்றோர் செயல்முறையிலிருந்து குழந்தை செயல்முறையை உருவாக்க நான் முட்கரண்டி () பயன்படுத்தினேன். பிறகு, நான் குழந்தை மற்றும் பெற்றோர் செயல்முறையிலிருந்து PID (செயல்முறை ஐடி) மற்றும் PPID (பெற்றோர் செயல்முறை ஐடி) அச்சிட்டேன். பெற்றோர் செயல்முறை காத்திருப்பு (NULL) குழந்தை செயல்முறை முடிவடையும் வரை காத்திருக்க பயன்படுத்தப்படுகிறது. குழந்தை செயல்பாட்டில், குழந்தை செயல்முறையை முடிக்க வெளியேறு () பயன்படுத்தப்படுகிறது. நீங்கள் பார்க்கிறபடி, பெற்றோர் செயல்முறையின் PID என்பது குழந்தை செயல்முறையின் PPID ஆகும். எனவே, குழந்தை செயல்முறை 24738 பெற்றோர் செயல்முறைக்கு சொந்தமானது 24731 .
உங்கள் நிரலை மேலும் மட்டுப்படுத்த நீங்கள் செயல்பாடுகளையும் பயன்படுத்தலாம். இங்கே, நான் பயன்படுத்தினேன் செயல்முறை பணி () மற்றும் பெற்றோர் பணி () குழந்தை மற்றும் பெற்றோர் செயல்முறைகளுக்கான செயல்பாடுகள் முறையே. ஃபோர்க் () உண்மையில் இப்படித்தான் பயன்படுத்தப்படுகிறது.
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
வெற்றிடம்குழந்தை பணி() {
printf (வணக்கம் உலகம் n');
}
வெற்றிடம்பெற்றோர் பணி() {
printf ('முக்கிய பணி. n');
}
intமுக்கிய(வெற்றிடம்) {
pid_t pid=முள் கரண்டி();
என்றால்(பிட்== 0) {
குழந்தை பணி();
வெளியேறு (EXIT_SUCCESS);
}
வேறு என்றால்(பிட்> 0) {
காத்திரு(ஏதுமில்லை);
பெற்றோர் பணி();
}
வேறு {
printf ('குழந்தை செயல்முறையை உருவாக்க முடியவில்லை.');
}
திரும்பEXIT_SUCCESS;
}
மேலே உள்ள நிரலின் வெளியீடு:
ஃபோர்க் () மற்றும் லூப் பயன்படுத்தி பல குழந்தை செயல்முறைகளை இயக்குகிறது:
உங்களுக்குத் தேவையான பல குழந்தை செயல்முறைகளை உருவாக்க நீங்கள் வளையத்தைப் பயன்படுத்தலாம். கீழேயுள்ள எடுத்துக்காட்டில், நான் லூப் பயன்படுத்தி 5 குழந்தை செயல்முறைகளை உருவாக்கியுள்ளேன். நான் குழந்தை செயல்முறைகளில் இருந்து PID மற்றும் PPID ஐ அச்சிட்டேன்.
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய(வெற்றிடம்) {
க்கான(intநான்= 1;நான்<= 5;நான்++) {
pid_t pid=முள் கரண்டி();
என்றால்(பிட்== 0) {
printf ('குழந்தை செயல்முறை => PPID =%d, PID =%d n',getppid(),getpid());
வெளியேறு (0);
}
வேறு {
printf ('பெற்றோர் செயல்முறை => PID =%d n',getpid());
printf ('குழந்தை செயல்முறைகள் முடிவடையும் வரை காத்திருக்கிறது ... n');
காத்திரு(ஏதுமில்லை);
printf ('குழந்தை செயல்முறை முடிந்தது. n');
}
}
திரும்பEXIT_SUCCESS;
}
நீங்கள் பார்க்க முடியும் என, அனைத்து குழந்தை செயல்முறைகளிலும் பெற்றோர் செயல்முறை ஐடி ஒன்றுதான். எனவே, அவர்கள் அனைவரும் ஒரே பெற்றோரைச் சேர்ந்தவர்கள். அவர்கள் நேரியல் பாணியிலும் செயல்படுத்துகிறார்கள். ஒன்றன் பின் ஒன்றாக. குழந்தை செயல்முறைகளை கட்டுப்படுத்துவது ஒரு அதிநவீன பணியாகும். லினக்ஸ் சிஸ்டம் புரோகிராமிங் மற்றும் அது எவ்வாறு இயங்குகிறது என்பது பற்றி மேலும் அறிந்து கொண்டால், இந்த செயல்முறைகளின் ஓட்டத்தை நீங்கள் எப்படி வேண்டுமானாலும் கட்டுப்படுத்தலாம்.
நிஜ வாழ்க்கை உதாரணம்:
Md5, sha256 போன்ற பல்வேறு சிக்கலான கணிதக் கணக்கீடுகளுக்கு நிறைய செயலாக்க சக்தி தேவைப்படுகிறது. முக்கிய திட்டத்தின் அதே செயல்பாட்டில் அது போன்ற விஷயங்களைக் கணக்கிடுவதற்குப் பதிலாக, நீங்கள் ஒரு குழந்தை செயல்பாட்டில் ஹாஷைக் கணக்கிட்டு ஹாஷை முக்கிய செயல்முறைக்குத் திருப்பி விடலாம்.
பின்வரும் எடுத்துக்காட்டில், நான் ஒரு குழந்தை செயல்பாட்டில் 4 இலக்க PIN குறியீட்டை உருவாக்கி, அதை பெற்றோர் செயல்முறை, முக்கிய நிரலுக்கு அனுப்புகிறேன். பின்னர், நான் அங்கிருந்து PIN குறியீட்டை அச்சிட்டேன்.
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
intgetPIN() {
// PPID மற்றும் PID ஐ விதையாக பயன்படுத்தவும்
srand (getpid() +getppid());
intஇரகசியம்= 1000 + வரிசை () % 9000;
திரும்பஇரகசியம்;
}
intமுக்கிய(வெற்றிடம்) {
intஎஃப்.டி[2];
குழாய்(எஃப்.டி);
pid_t pid=முள் கரண்டி();
என்றால்(பிட்> 0) {
நெருக்கமான(0);
நெருக்கமான(எஃப்.டி[1]);
பிறகு(எஃப்.டி[0]);
intரகசிய எண்;
size_tபடிக்க பைட்டுகள்=படி(எஃப்.டி[0], &ரகசிய எண், அளவு(ரகசிய எண்));
printf (PIN க்காக காத்திருக்கிறது ... n');
காத்திரு(ஏதுமில்லை);
printf (பைட்டுகள் படிக்க: %ld n',படிக்க பைட்டுகள்);
printf (பின்: %d n',ரகசிய எண்);
}
வேறு என்றால்(பிட்== 0) {
நெருக்கமான(1);
நெருக்கமான(எஃப்.டி[0]);
பிறகு(எஃப்.டி[1]);
intஇரகசியம்=getPIN();
எழுது(எஃப்.டி[1], &இரகசியம், அளவு(இரகசியம்));
வெளியேறு (EXIT_SUCCESS);
}
திரும்பEXIT_SUCCESS;
}
நீங்கள் பார்க்க முடியும் என, ஒவ்வொரு முறையும் நான் நிரலை இயக்கும்போது, எனக்கு 4 இலக்க PIN குறியீடு வேறு கிடைக்கும்.
எனவே, அடிப்படையில் நீங்கள் லினக்ஸில் ஃபோர்க் () சிஸ்டம் அழைப்பை எப்படிப் பயன்படுத்துகிறீர்கள். இந்தக் கட்டுரையைப் படித்ததற்கு நன்றி.