'ஒவ்வொரு நிரலாக்க மொழியும் குறிப்பிட்ட நோக்கங்களுக்காக பல நூலகங்களைக் கொண்டிருந்தாலும், C இன் POSIX நூலகம் அதன் இடத்தைப் பெற்றுள்ளது. இது செயல்முறைகளுக்கு இடையே ஒரு சிறந்த ஒத்திசைவை உருவாக்க வடிவமைக்கப்பட்டுள்ளது மற்றும் நிரல்களுக்குள் மல்டித்ரெடிங்கைப் பயன்படுத்துவதற்கு நிறைய உதவுகிறது, அதாவது, பல நூல்களை உருவாக்கி அவற்றின் செயல்பாட்டை ஒத்திசைக்கிறது. இன்று இந்த வழிகாட்டியில், C இல் POSIX செமாஃபோர்களைப் பயன்படுத்துவதற்கான எளிய விளக்கத்தைக் காண்பீர்கள். அடிப்படை C குறியீடு எடுத்துக்காட்டுகளுக்கு, கணினியில் அதன் தொகுப்பியை நாம் கட்டமைக்க வேண்டும். ஆனால், அதற்கு முன், நாம் கணினியைப் புதுப்பிக்க வேண்டும், ஏனெனில் இது குறியீட்டை சீராகச் செயல்படுத்துவதற்கு அவசியமான படியாகும். எனவே, இணைக்கப்பட்ட ஸ்னாப்பில் காட்டப்படும் வினவல் உங்கள் லினக்ஸ் இயங்குதளத்தை 'apt' பயன்பாட்டுடன் புதுப்பிக்கவும் மேம்படுத்தவும் வேண்டும்.
புதுப்பிப்புகளைச் சீராகச் செய்ய, இந்தச் செயல்முறைக்கு உங்கள் லினக்ஸ் இயங்குதளத்தில் சுமார் 55 Kb இடம் தேவைப்படுகிறது. நீங்கள் இவ்வளவு இடத்தைக் கொடுக்க விரும்பினால், தொடர 'y' என்பதைத் தட்டவும். சில நிமிடங்களில் செயலாக்கம் முடிவடையும்.
கணினி முழுமையாக மேம்படுத்தப்பட்ட பிறகு, 'install' கட்டளையில் உள்ள apt-get பயன்பாட்டுடன், C மொழியின் கம்பைலரை நமது கணினியில் உள்ளமைக்கப் போகிறோம். 'gcc' ஒரு முக்கிய சொல்லாக பயன்படுத்தவும், அவ்வளவுதான்.
செம்_இனிட்()
's' இல் ஏற்கனவே அடையாளம் காணப்படாத செமாஃபோர் இருக்கும்போது புதிய செமாஃபோர் உருவாக்கப்படும்; இல்லையெனில், ஏற்கனவே இருக்கும் செமாஃபோர் நிராகரிக்கப்படும். இந்த முறை முழுவதும், 's' என்பது ஒரு செமாஃபோர் நிகழ்வைக் குறிக்கிறது, மேலும் பகிர்வு என்பது ஒரு சிக்னல் அல்லது பென்னண்ட் ஆகும். உள்ளீட்டு மதிப்பு செமாஃபோரின் தொடக்க புள்ளியாக செயல்படுகிறது.
Int sem_init ( அல்லது_t * s, int பகிரப்பட்ட, கையொப்பமிடப்படாத முழு எண்ணாக மதிப்பு ) ;
செம்_வெயிட்()
's' ஆல் குறிப்பிடப்பட்ட செமாஃபோரின் மீது ஒரு செமாஃபோர் பூட்டு செயலை செயல்படுத்துவதன் மூலம், sem_wait() முறையானது அந்த செமாஃபோரை வைத்திருக்கும். செம்-காத்திருப்பு செயல்முறை செமாஃபோரைத் தக்கவைக்க அல்லது அதை வரிசையில் நிற்க அனுமதிக்கும். வேறு சில செயல்முறைகள் sem_post() ஐ செயல்படுத்தும் போது, முன்பு ஓவர்லோட் செய்யப்பட்ட சில செயல்முறைகள் எழுகின்றன.
int sem_wait ( அல்லது_t * கள் ) ;
no_post()
செம் போஸ்ட் என்று அழைக்கப்படும் போது, மதிப்பு அதிகரிக்கப்படுகிறது, அதன்பின் முன்பு காப்புப் பிரதி எடுக்கப்பட்ட அல்லது காத்திருக்கும் செயல்பாடுகளில் ஒன்று இயங்கத் தொடங்குகிறது, அதாவது, ஏற்கனவே பூட்டிய செமாஃபோரைத் திறக்கும்.
int sem_post ( அல்லது_t * கள் ) ;
இல்லை_அழித்தல்()
தொடங்கப்பட்ட பெயரிடப்படாத செமாஃபோர் “கள்” செம் அழிக்கும்() செயல்பாட்டைப் பயன்படுத்தி அழிக்கப்படுகிறது.
int sem_destroy ( அல்லது_t * கள் ) ;
உதாரணமாக
செமாஃபோர்களைப் புரிந்து கொள்ள, முதலில் ஒரு C கோப்பை உருவாக்கி, அதில் ஒரு குறியீட்டைச் சேர்க்கப் போகிறோம். ஒன்றை உருவாக்க, 'டச்' வினவலைப் பயன்படுத்தவும், உங்கள் கணினியின் முகப்பு கோப்புறையில் புதிய கோப்பைக் காண்பீர்கள்.
இப்போது, உங்கள் வெற்று C கோப்பை அதில் நல்ல குறியீட்டை உருவாக்க சில எளிய எடிட்டருடன் திறக்க வேண்டும். கீழே உள்ள ஸ்னாப்பில் காட்டப்பட்டுள்ளபடி, இதுவரை “நானோ” எடிட்டரை முயற்சித்து வருகிறோம்.
அனைத்து நிரலாக்க மொழிகளும் நூலகங்கள் இல்லாமல் இயங்க முடியாது என்பதை நாம் அனைவரும் அறிவோம், ஏனெனில் இந்த நூலகங்கள் அதிக எண்ணிக்கையிலான வகுப்புகள், கட்டமைப்புகள், செயல்பாடுகள் மற்றும் ஒட்டுமொத்த கணினி வேலைக்காகப் பயன்படுத்தப்படும் பொருள்களைக் கொண்டுள்ளன. எனவே POSIX Semaphores க்கான சில அடிப்படை மற்றும் கட்டாயம் வைத்திருக்க வேண்டிய நூலகங்களைப் பயன்படுத்தி இந்த C நிரலைத் தொடங்குகிறோம்.
குறியீட்டில் இந்த நூலகங்களைப் பயன்படுத்த, ஒவ்வொரு நூலகத்திற்கும் 'உள்படுத்து' என்ற முக்கிய சொல்லுடன் '#' எழுத்தைப் பயன்படுத்த வேண்டும். இப்போது, இந்தத் திட்டத்தில் இருக்க வேண்டிய மொத்தம் 4 நூலகங்களைச் சேர்த்துள்ளோம். இல்லையெனில், எங்கள் திட்டம் சரியாக வேலை செய்யாது. முதல் 'stdio.h' தலைப்பு நூலகம் பொதுவாக ஒவ்வொரு C நிரலிலும் கண்டிப்பாக இருக்க வேண்டும், ஏனெனில் இது குறியீட்டில் உள்ளீடு மற்றும் வெளியீட்டு செயல்பாடுகளை அனுமதிக்கிறது. எனவே, குறியீட்டிலிருந்து உள்ளீடுகளைச் சேர்க்க மற்றும் வெளியீடுகளைப் பெற இதைப் பயன்படுத்துகிறோம். நாம் இங்கு பயன்படுத்தும் இரண்டாவது நூலகம் 'pthread.h' ஆகும், இது நூல் நிரலாக்கத்தைப் பயன்படுத்துவதற்கு அவசியம், அதாவது மல்டித்ரெடிங்.
நிரலில் நூல்களை உருவாக்க இந்த நூலகத்தைப் பயன்படுத்துவோம். இந்தக் குறியீட்டின் அடுத்த மற்றும் மிக முக்கியமான நூலகம் 'semaphore.h' ஆகும். நூல்களை சீராக ஒத்திசைக்க இது பயன்படுத்தப்பட்டது. கடைசியாக ஆனால் குறைந்தது அல்ல, நூலகம் 'unistd.h' ஆகும், இது பயனர் வரையறுக்கப்பட்ட இதர செயல்பாடுகள் மற்றும் மாறிலிகளைப் பயன்படுத்த உதவுகிறது. இப்போது, செமாஃபோர் நூலகத்தின் 'sem_t' உள்ளமைக்கப்பட்ட பொருளைப் பயன்படுத்தி 's' செமாஃபோரை அறிவித்துள்ளோம். திரும்பும் வகை இல்லாமல் த்ரெட் பயனர் வரையறுக்கப்பட்ட செயல்பாடு “T” இங்கே வருகிறது. இது ஒத்திசைவைச் செய்ய சில உள்ளமைக்கப்பட்ட செமாஃபோர் செயல்பாடுகளைப் பயன்படுத்துகிறது. '&' எழுத்தைப் பயன்படுத்தி செமாஃபோர் 's' ஐ வைத்திருக்க sem_wait() செயல்பாடு உள்ளது.
இந்த நிரலை 4 வினாடிகள் தூங்கச் செய்ய, 'ஸ்லீப்' செயல்பாட்டுடன், பிடிப்புக்குள், printf() அறிக்கை செயல்படுத்தப்பட்டது. மற்றொரு printf() அறிக்கை ஒரு புதிய செய்தியைக் காட்டுகிறது, மேலும் செமாஃபோர் “s” இல் பூட்டை வெளியிட sem_post() செயல்பாடு செயல்படுத்தப்படுகிறது.
##
# அடங்கும்
#உள்ளடக்க
இல்லை_t கள்;
வெற்றிடமானது * டி ( வெற்றிடமானது * arg ) {
செம்_காத்திரு ( & கள் ) ;
printf ( 'வரவேற்பு! \n ' ) ;
தூங்கு ( 4 ) ;
printf ( 'வருகிறேன்! \n ' ) ;
செம்_போஸ்ட் ( & கள் ) ;
}
செமாஃபோர்களுக்கான இந்த சி நிரலின் முக்கிய() முறையை நன்றாகப் பார்ப்போம். sem_init() செயல்பாடு ஒரு புதிய semaphore 's' ஐ உருவாக்குவதற்கு பயன்படுத்தப்பட்டது, அது ஒரு forked() முறையில் விநியோகிக்கப்படவில்லை, அதாவது, '0', மற்றும் அதன் தொடக்கப் புள்ளி 1 என அமைக்கப்பட்டுள்ளது. pthread இலிருந்து pthread_t பொருள் O1 மற்றும் o2 ஆகிய இரண்டு நூல் பொருள்களைப் பயன்படுத்தி இரண்டு நூல்களை உருவாக்க C நூலகம் பயன்படுத்தப்பட்டது. அடுத்த வரியில் pthread_create() செயல்பாட்டைப் பயன்படுத்தி முதல் நூலை உருவாக்கப் போகிறோம் என்பதைக் காட்ட printf() அறிக்கை இங்கே உள்ளது.
இந்த செயல்பாட்டிற்கு ஓ1 த்ரெட் ஆப்ஜெக்ட்டை NULL கட்டுப்பாடுகளுடன் அனுப்புகிறோம் மற்றும் அதை அளவுருக்களில் அனுப்புவதன் மூலம் செயல்பாட்டை “T” என்று அழைக்கிறோம். 4 வினாடிகள் உறக்கத்திற்குப் பிறகு, ஆப்ஜெக்ட் o2 உடன் மற்றொரு த்ரெட் உருவாக்கப்பட்டது, மேலும் pthread_join() செயல்பாடு முக்கிய() செயல்பாட்டுடன் இழைகளை இணைக்க இங்கே பயன்படுத்தப்படுகிறது. 's' செமாஃபோரை அழிக்க sem_destroy() செயல்பாடு உள்ளது, மேலும் தடுக்கப்பட்ட அனைத்து நூல்களும் வெளியிடப்படும்.
முழு எண்ணாக ( ) {செம்_இனிட் ( & கள், 0 , 1 ) ;
pthread_t o1, o2;
printf ( 'இப்போது 1வது திரியில்... \n ' ) ;
pthread_create ( & o1,NULL,T,NULL ) ;
தூங்கு ( 4 ) ;
printf ( 'இப்போது 2வது திரியில்... \n ' ) ;
pthread_create ( & o2,NULL,T,NULL ) ;
pthread_join ( o1, NULL ) ;
pthread_join ( o2, NULL ) ;
இல்லை_அழித்தல் ( & கள் ) ;
திரும்ப 0 ;
}
'Gcc' கம்பைலர் மூலம் C நிரலை தொகுக்கிறோம்; '-lrt' மற்றும் '-lpthread' விருப்பங்கள் POSIX நூல் செயல்பாடுகளை செயல்படுத்த பயன்படுத்தப்படுகின்றன. “.a/.out” வினவலை இயக்கும் போது, முதல் தொடரிழை உருவாக்கப்பட்டது. முதல் செய்தியை அச்சிட்ட பிறகு அது தூங்கிவிடும்.
இரண்டாவது த்ரெட் ஒத்திசைக்கப்பட்டது, 4 வினாடிகளுக்குப் பிறகு, முதல் நூல் வெளியிடப்பட்டது, இரண்டாவது த்ரெட் 4 வினாடிகளுக்குப் பூட்டப்பட்டது.
இறுதியில் இரண்டாவது இழையும் வெளியானது.
முடிவுரை
C இல் உள்ள POSIX Semaphores ஐப் பற்றியது, அதே நேரத்தில் வெவ்வேறு நூல்களை ஒத்திசைக்க அதன் சில முக்கிய செயல்பாடுகளைப் பயன்படுத்துகிறது. இந்தக் கட்டுரையைப் படித்த பிறகு, நீங்கள் POSIX ஐ மேலும் மேலும் புரிந்து கொள்ள முடியும்.