ஃபோர்க் சிஸ்டம் அழைப்பு ஒரு புதிய செயல்முறைகளை உருவாக்க பயன்படுகிறது. புதிதாக உருவாக்கப்பட்ட செயல்முறை குழந்தை செயல்முறை ஆகும். முட்கரண்டி மற்றும் புதிய செயல்முறையை உருவாக்கும் செயல்முறை பெற்றோர் செயல்முறை ஆகும். குழந்தை மற்றும் பெற்றோர் செயல்முறைகள் ஒரே நேரத்தில் செயல்படுத்தப்படுகின்றன.
ஆனால் குழந்தை மற்றும் பெற்றோர் செயல்முறைகள் வெவ்வேறு நினைவக இடைவெளிகளில் வாழ்கின்றன. இந்த நினைவக இடைவெளிகள் ஒரே உள்ளடக்கத்தைக் கொண்டுள்ளன மற்றும் ஒரு செயல்முறையால் செய்யப்படும் எந்த செயல்பாடும் மற்ற செயல்முறையை பாதிக்காது.
குழந்தை செயல்முறைகள் உருவாக்கப்படும் போது; இப்போது இரண்டு செயல்முறைகளும் ஒரே நிரல் கவுண்டரை (பிசி) கொண்டிருக்கும், எனவே இந்த இரண்டு செயல்முறைகளும் ஒரே அடுத்த அறிவுறுத்தலை சுட்டிக்காட்டும். பெற்றோர் செயல்முறையால் திறக்கப்பட்ட கோப்புகள் குழந்தை செயல்முறைக்கு ஒரே மாதிரியாக இருக்கும்.
குழந்தை செயல்முறை அதன் பெற்றோரைப் போலவே உள்ளது, ஆனால் செயல்முறைகள் ஐடியில் வேறுபாடு உள்ளது:
- குழந்தை செயல்முறையின் செயல்முறை ஐடி ஒரு தனிப்பட்ட செயல்முறை ஐடி ஆகும், இது தற்போதுள்ள மற்ற அனைத்து செயல்முறைகளின் ஐடியிலிருந்து வேறுபட்டது.
- பெற்றோர் செயல்முறை ஐடி குழந்தையின் பெற்றோரின் செயல்முறை ஐடியைப் போலவே இருக்கும்.
குழந்தை செயல்முறையின் பண்புகள்
ஒரு குழந்தை செயல்முறை வைத்திருக்கும் சில பண்புகள் பின்வருமாறு:
- பூஜ்ஜியத்திற்கு மீட்டமைக்க CPU கவுண்டர்கள் மற்றும் ஆதாரப் பயன்பாடுகள் துவக்கப்பட்டுள்ளன.
- பெற்றோர் செயல்முறை முடிவடையும் போது, PRCTL () இல் PR_SET_PDEATHSIG பண்பு மீட்டமைக்கப்படுவதால், குழந்தை செயல்முறைகள் எந்த சமிக்ஞையையும் பெறாது.
- ஃபோர்க் () என்று அழைக்கப்படும் நூல் குழந்தை செயல்முறையை உருவாக்குகிறது. எனவே குழந்தையின் செயல்முறையின் முகவரி பெற்றோரின் முகவரியைப் போலவே இருக்கும்.
- பெற்றோர் செயல்முறையின் கோப்பு விவரக்குறிப்பு குழந்தை செயல்முறையால் பெறப்படுகிறது. எடுத்துக்காட்டாக, கோப்பின் ஆஃப்செட் அல்லது கொடியின் நிலை மற்றும் I/O பண்புக்கூறுகள் குழந்தை மற்றும் பெற்றோர் செயல்முறைகளின் கோப்பு விளக்கத்தில் பகிரப்படும். எனவே பெற்றோர் வகுப்பின் கோப்பு விவரக்குறிப்பு குழந்தை வகுப்பின் அதே கோப்பு விளக்கத்தை குறிக்கும்.
- பெற்றோர் செயல்முறையின் திறந்த செய்தி வரிசை விளக்கங்கள் குழந்தை செயல்முறையால் பெறப்படுகின்றன. உதாரணமாக ஒரு கோப்பு விளக்கத்தில் பெற்றோர் செயலியில் ஒரு செய்தி இருந்தால், அதே செயல்முறை குழந்தை செயல்முறையின் தொடர்புடைய கோப்பு விளக்கத்தில் இருக்கும். எனவே இந்த கோப்பு விளக்கங்களின் கொடி மதிப்புகள் ஒன்றே என்று நாம் கூறலாம்.
- இதேபோல் திறந்த அடைவு ஸ்ட்ரீம்கள் குழந்தை செயல்முறைகளால் பெறப்படும்.
- குழந்தை வகுப்பின் இயல்புநிலை டைமர் ஸ்லாக் மதிப்பு பெற்றோர் வகுப்பின் தற்போதைய டைமர் ஸ்லாக் மதிப்பைப் போன்றது.
குழந்தை செயல்முறையால் பெறப்படாத பண்புகள்
பின்வருபவை குழந்தை செயல்முறையால் மரபுரிமையாக இல்லாத சில பண்புகள்:
- நினைவக பூட்டுகள்
- குழந்தை வகுப்பின் நிலுவையில் உள்ள சமிக்ஞை காலியாக உள்ளது.
- தொடர்புடைய பதிவு பூட்டுகளை செயலாக்கு (fcntl ())
- ஒத்திசைவற்ற I/O செயல்பாடுகள் மற்றும் I/O உள்ளடக்கங்கள்.
- அடைவு மாற்ற அறிவிப்புகள்.
- அலாரம் (), செடிடிமர் () போன்ற டைமர்கள் குழந்தை வகுப்பால் பெறப்படவில்லை.
சி இல் முட்கரண்டி ()
முட்கரண்டி () இல் எந்த வாதங்களும் இல்லை மற்றும் திரும்பும் வகை முள் () முழு எண்ணாகும். ஃபோர்க் () பயன்படுத்தும் போது பின்வரும் தலைப்பு கோப்புகளை நீங்கள் சேர்க்க வேண்டும்:
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
முட்கரண்டி () உடன் வேலை செய்யும் போது, வகைக்குப் பயன்படுத்தலாம் pid_t செயலாக்க ID களுக்கு pid_t வரையறுக்கப்பட்டுள்ளது.
ஃபோர்க் () வரையறுக்கப்பட்டுள்ள இடத்தில் தலைப்பு கோப்பு உள்ளது, எனவே ஃபோர்க் () ஐப் பயன்படுத்த நீங்கள் அதை உங்கள் நிரலில் சேர்க்க வேண்டும்.
திரும்பும் வகை வரையறுக்கப்பட்டுள்ளது மற்றும் ஃபோர்க் () அழைப்பு வரையறுக்கப்பட்டுள்ளது. எனவே, ஃபோர்க் () கணினி அழைப்பைப் பயன்படுத்த உங்கள் நிரலில் இரண்டையும் நீங்கள் சேர்க்க வேண்டும்.
ஃபோர்க்கின் தொடரியல் ()
லினக்ஸ், உபுண்டுவில் ஃபோர்க் () சிஸ்டம் அழைப்பின் தொடரியல் பின்வருமாறு:
pid_t முட்கரண்டி (வெற்றிடம்);தொடரியலில் திரும்பும் வகை pid_t . குழந்தை செயல்முறை வெற்றிகரமாக உருவாக்கப்படும்போது, குழந்தை செயல்முறையின் PID ஆனது பெற்றோர் செயல்பாட்டில் திரும்பும் மற்றும் 0 குழந்தை செயல்முறைக்குத் திரும்பும்.
ஏதேனும் பிழை இருந்தால் -1 பெற்றோர் செயல்முறைக்குத் திரும்பும் மற்றும் குழந்தை செயல்முறை உருவாக்கப்படவில்லை.
No arguments are passed to fork().
எடுத்துக்காட்டு 1: அழைப்பு முட்கரண்டி ()
ஒரு புதிய குழந்தை செயல்முறையை உருவாக்க நாங்கள் முட்கரண்டி () கணினி அழைப்பைப் பயன்படுத்திய பின்வரும் உதாரணத்தைக் கவனியுங்கள்:
குறியீடு:
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய()
{
முள் கரண்டி();
printf (ஃபோர்க் () கணினி அழைப்பைப் பயன்படுத்துதல் n');
திரும்ப 0;
}
வெளியீடு:
ஃபோர்க் () கணினி அழைப்பைப் பயன்படுத்துதல்ஃபோர்க் () கணினி அழைப்பைப் பயன்படுத்துதல்
இந்த திட்டத்தில், நாங்கள் ஃபோர்க் () பயன்படுத்தியுள்ளோம், இது ஒரு புதிய குழந்தை செயல்முறையை உருவாக்கும். குழந்தை செயல்முறை உருவாக்கப்படும் போது, பெற்றோர் செயல்முறை மற்றும் குழந்தை செயல்முறை இரண்டும் அடுத்த அறிவுறுத்தலை (அதே நிரல் கவுண்டர்) சுட்டிக்காட்டும். இந்த வழியில் மீதமுள்ள அறிவுறுத்தல்கள் அல்லது சி அறிக்கைகள் செயல்முறை நேரங்களின் மொத்த எண்ணிக்கையை செயல்படுத்தும், அதாவது 2என்முறை, n என்பது ஃபோர்க் () கணினி அழைப்புகளின் எண்ணிக்கை.
முட்கரண்டி () அழைப்பு மேலே உள்ளதைப் போல ஒரு முறை பயன்படுத்தப்படும்போது (21= 2) நம் வெளியீடு 2 முறை இருக்கும்.
இங்கே ஃபோர்க் () சிஸ்டம் கால் பயன்படுத்தும்போது, உள் அமைப்பு இப்படி இருக்கும்:
முட்கரண்டி () 4 முறை பயன்படுத்தப்படும் பின்வரும் வழக்கைக் கவனியுங்கள்:
குறியீடு:
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய()
{
முள் கரண்டி();
முள் கரண்டி();
முள் கரண்டி();
முள் கரண்டி();
printf ('ஃபோர்க் () கணினி அழைப்பைப் பயன்படுத்துதல்');
திரும்ப 0;
}
வெளியீடு:
Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call
இப்போது உருவாக்கப்பட்ட மொத்த செயல்முறைகளின் எண்ணிக்கை 2 ஆகும்4= 16 மற்றும் எங்கள் அச்சு அறிக்கை 16 முறை செயல்படுத்தப்பட்டது.
எடுத்துக்காட்டு 2: முட்கரண்டி () வெற்றிகரமாக இருந்தால் சோதனை
பின்வரும் எடுத்துக்காட்டில், முட்கரண்டி () மூலம் பெறப்பட்ட மதிப்பை (int) சோதிக்க முடிவெடுக்கும் கட்டமைப்பைப் பயன்படுத்தினோம். அதனுடன் தொடர்புடைய செய்திகள் காட்டப்படும்:
குறியீடு:
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய()
{
pid_t ப;
ப=முள் கரண்டி();
என்றால்(ப== -1)
{
printf (ஃபோர்க் () ஐ அழைக்கும் போது பிழை உள்ளது);
}
என்றால்(ப==0)
{
printf ('நாங்கள் குழந்தை செயல்பாட்டில் இருக்கிறோம்');
}
வேறு
{
printf ('நாங்கள் பெற்றோர் செயல்பாட்டில் இருக்கிறோம்');
}
திரும்ப 0;
}
வெளியீடு:
நாங்கள் பெற்றோர் செயல்பாட்டில் இருக்கிறோம்நாங்கள் குழந்தை செயல்பாட்டில் இருக்கிறோம்
மேலே உள்ள எடுத்துக்காட்டில் நாம் pid_t வகையைப் பயன்படுத்தியுள்ளோம். ஃபோர்க் () லைனில் அழைக்கப்படுகிறது:
ப=முள் கரண்டி();முட்கரண்டி () மூலம் திரும்பப்பெறும் முழு எண் மதிப்பு p இல் சேமிக்கப்படுகிறது, பின்னர் p என்பது எங்கள் முட்கரண்டி () அழைப்பு வெற்றிகரமாக இருந்ததா என ஒப்பிடப்படுகிறது.
ஃபோர்க் () அழைப்பு பயன்படுத்தப்பட்டு குழந்தை வெற்றிகரமாக உருவாக்கப்படும் போது, குழந்தை செயல்முறை ஐடி பெற்றோர் செயல்முறைக்கு திரும்பும் மற்றும் 0 குழந்தை செயல்முறைக்கு திரும்பும். பெற்றோர் செயல்பாட்டில் குழந்தை செயல்முறையின் ஐடி அதே போல் இருக்காது குழந்தை செயல்முறையில் குழந்தை செயல்முறையின் ஐடி. குழந்தை செயல்பாட்டில் ஐடி செயல்முறை 0 ஆக இருக்கும்.
இந்த டுடோரியல் மூலம் லினக்ஸில் ஃபோர்க் சிஸ்டம் அழைப்பை எப்படி தொடங்குவது என்று பார்க்கலாம்.