நூல்களை நிர்வகித்தல். ஆவியாகும் முக்கிய சொல் மற்றும் விளைச்சல்() முறை

வணக்கம்! மல்டித்ரெடிங் பற்றிய எங்கள் படிப்பைத் தொடர்கிறோம். volatileஇன்று நாம் முக்கிய வார்த்தை மற்றும் முறை பற்றி அறிந்து கொள்வோம் yield(). உள்ளே நுழைவோம் :)

கொந்தளிப்பான முக்கிய சொல்

மல்டித்ரெட் அப்ளிகேஷன்களை உருவாக்கும் போது, ​​நாம் இரண்டு கடுமையான பிரச்சனைகளை சந்திக்கலாம். முதலாவதாக, மல்டித்ரெட் செய்யப்பட்ட பயன்பாடு இயங்கும் போது, ​​வெவ்வேறு நூல்கள் மாறிகளின் மதிப்புகளைத் தேக்கிக்கொள்ள முடியும் (இதைப் பற்றி நாம் ஏற்கனவே 'வாலாடைலைப் பயன்படுத்துதல்' என்ற பாடத்தில் பேசினோம் ). ஒரு த்ரெட் மாறியின் மதிப்பை மாற்றும் சூழ்நிலையை நீங்கள் பெறலாம் , ஆனால் இரண்டாவது திரி மாற்றத்தைக் காணவில்லை, ஏனெனில் அது மாறியின் தற்காலிக சேமிப்பில் உள்ள நகலுடன் வேலை செய்கிறது. இயற்கையாகவே, விளைவுகள் தீவிரமாக இருக்கலாம். இது பழைய மாறி மட்டும் அல்ல, மாறாக உங்கள் வங்கிக் கணக்கு இருப்பு, திடீரென்று தோராயமாக மேலும் கீழும் குதிக்கத் தொடங்கும் என்று வைத்துக்கொள்வோம் :) அது வேடிக்கையாகத் தெரியவில்லை, இல்லையா? இரண்டாவதாக, ஜாவாவில், அனைத்து பழமையான வகைகளையும் படிக்க மற்றும் எழுதுவதற்கான செயல்பாடுகள்,longdouble, அணுக்கள். சரி, எடுத்துக்காட்டாக, நீங்கள் ஒரு திரியில் மாறியின் மதிப்பை மாற்றினால் int, மற்றொரு திரியில் மாறியின் மதிப்பைப் படித்தால், நீங்கள் அதன் பழைய மதிப்பைப் பெறுவீர்கள் அல்லது புதியதைப் பெறுவீர்கள், அதாவது மாற்றத்தின் விளைவாக ஏற்பட்ட மதிப்பைப் பெறுவீர்கள். நூல் 1 இல். 'இடைநிலை மதிப்புகள்' இல்லை. longஇருப்பினும், இது s மற்றும் doubles உடன் வேலை செய்யாது . ஏன்? குறுக்கு-தளம் ஆதரவின் காரணமாக. ஜாவாவின் வழிகாட்டுதல் கொள்கை 'ஒருமுறை எழுதுங்கள், எங்கு வேண்டுமானாலும் ஓடுங்கள்' என்று ஆரம்ப நிலைகளில் நாங்கள் கூறியது நினைவிருக்கிறதா? அதாவது குறுக்கு-தளம் ஆதரவு. வேறு வார்த்தைகளில் கூறுவதானால், ஒரு ஜாவா பயன்பாடு பல்வேறு தளங்களில் இயங்குகிறது. எடுத்துக்காட்டாக, விண்டோஸ் இயக்க முறைமைகளில், Linux அல்லது MacOS இன் வெவ்வேறு பதிப்புகள். அவை அனைத்திலும் ஒரு தடங்கலும் இல்லாமல் ஓடும். 64 பிட்களில் எடை கொண்டது,longdoubleஜாவாவில் உள்ள 'கடுமையான' பழமையானவை. மேலும் சில 32-பிட் இயங்குதளங்கள் அணு வாசிப்பு மற்றும் 64-பிட் மாறிகள் எழுதுவதை செயல்படுத்துவதில்லை. இத்தகைய மாறிகள் இரண்டு செயல்பாடுகளில் படிக்கப்பட்டு எழுதப்படுகின்றன. முதலில், முதல் 32 பிட்கள் மாறிக்கு எழுதப்படுகின்றன, பின்னர் மற்றொரு 32 பிட்கள் எழுதப்படுகின்றன. இதன் விளைவாக, ஒரு சிக்கல் ஏற்படலாம். ஒரு திரி சில 64-பிட் மதிப்பை ஒரு Xமாறிக்கு எழுதுகிறது மற்றும் இரண்டு செயல்பாடுகளில் அவ்வாறு செய்கிறது. அதே நேரத்தில், இரண்டாவது நூல் மாறியின் மதிப்பைப் படிக்க முயற்சிக்கிறது மற்றும் அந்த இரண்டு செயல்பாடுகளுக்கு இடையில் அவ்வாறு செய்கிறது - முதல் 32 பிட்கள் எழுதப்பட்டபோது, ​​ஆனால் இரண்டாவது 32 பிட்கள் இல்லை. இதன் விளைவாக, இது ஒரு இடைநிலை, தவறான மதிப்பைப் படிக்கிறது, மேலும் எங்களிடம் பிழை உள்ளது. எடுத்துக்காட்டாக, அத்தகைய மேடையில் 9223372036854775809 என்ற எண்ணுக்கு எழுத முயற்சிக்கிறோம் ஒரு மாறிக்கு, அது 64 பிட்களை ஆக்கிரமிக்கும். பைனரி வடிவத்தில், இது இப்படித் தோன்றுகிறது: 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 . முதலில், இது முதல் 32 பிட்கள் ( 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 ) மேலும், இந்தச் செயல்பாடுகளுக்கு இடையே, இரண்டாவது நூல், மாறியின் இடைநிலை மதிப்பை (10000000000000000000000000000000000000000) படிக்கலாம், அவை ஏற்கனவே எழுதப்பட்ட முதல் 32 பிட்கள் ஆகும். தசம அமைப்பில், இந்த எண் 2,147,483,648 ஆகும். வேறு வார்த்தைகளில் கூறுவதானால், 9223372036854775809 என்ற எண்ணை ஒரு மாறிக்கு எழுத விரும்பினோம், ஆனால் இந்த செயல்பாடு சில தளங்களில் அணுசக்தியாக இல்லாததால், எங்களிடம் 2,147,483,648 என்ற தீய எண் உள்ளது, இது எங்கிருந்தும் வெளியே வந்து அறியப்படாத விளைவை ஏற்படுத்தும். திட்டம். இரண்டாவது நூல் எழுதி முடிப்பதற்குள் மாறியின் மதிப்பை எளிமையாகப் படிக்கும், அதாவது நூல் முதல் 32 பிட்களைக் கண்டது, ஆனால் இரண்டாவது 32 பிட்கள் அல்ல. நிச்சயமாக, இந்த பிரச்சினைகள் இன்று நேற்று எழுந்தவை அல்ல. ஜாவா அவற்றை ஒரு முக்கிய வார்த்தை மூலம் தீர்க்கிறது: volatile. நாம் பயன்படுத்தினால்volatileஎங்கள் நிரலில் சில மாறிகளை அறிவிக்கும் போது முக்கிய வார்த்தை…

public class Main {

   public volatile long x = 2222222222222222222L;

   public static void main(String[] args) {

   }
}

…அதன் அர்த்தம்:

1. எப்பொழுதும் அணுஅணுவாகப் படித்து எழுதப்படும். அது 64-பிட் doubleஅல்லது long.
2. ஜாவா இயந்திரம் அதை கேச் செய்யாது. எனவே 10 நூல்கள் அவற்றின் சொந்த உள்ளூர் நகல்களுடன் வேலை செய்யும் சூழ்நிலை உங்களுக்கு இருக்காது.

எனவே, இரண்டு மிகக் கடுமையான சிக்கல்கள் ஒரே வார்த்தையில் தீர்க்கப்படுகின்றன :)

மகசூல் () முறை

வகுப்பின் பல முறைகளை நாங்கள் ஏற்கனவே மதிப்பாய்வு செய்துள்ளோம் Thread, ஆனால் உங்களுக்கு புதியதாக இருக்கும் முக்கியமான ஒன்று உள்ளது. அது yield()முறை . அதன் பெயர் என்ன சொல்கிறதோ அதையே அது செய்கிறது! ஒரு நூலில் உள்ள முறையை நாம் அழைக்கும் போது yield, ​​அது உண்மையில் மற்ற இழைகளுடன் பேசுகிறது: 'ஏய், தோழர்களே. நான் எங்கும் செல்ல எந்த அவசரமும் இல்லை, எனவே உங்களில் யாருக்காவது செயலி நேரத்தைப் பெறுவது முக்கியம் என்றால், அதை எடுத்துக் கொள்ளுங்கள் — நான் காத்திருக்க முடியும். இது எவ்வாறு செயல்படுகிறது என்பதற்கான எளிய எடுத்துக்காட்டு இங்கே:

public class ThreadExample extends Thread {

   public ThreadExample() {
       this.start();
   }

   public void run() {

       System.out.println(Thread.currentThread().getName() + " yields its place to others");
       Thread.yield();
       System.out.println(Thread.currentThread().getName() + " has finished executing.");
   }

   public static void main(String[] args) {
       new ThreadExample();
       new ThreadExample();
       new ThreadExample();
   }
}

நாங்கள் தொடர்ச்சியாக மூன்று இழைகளை உருவாக்கி தொடங்குகிறோம்: Thread-0, Thread-1, மற்றும் Thread-2. Thread-0முதலில் தொடங்கி உடனடியாக மற்றவர்களுக்கு விளைகிறது. பின்னர் Thread-1தொடங்கப்பட்டு விளைச்சலையும் தருகிறது. பின்னர் Thread-2தொடங்கப்பட்டது, அதுவும் விளைகிறது. எங்களிடம் இனி நூல்கள் எதுவும் இல்லை, Thread-2அதன் இடத்தை கடைசியாகப் பெற்ற பிறகு, த்ரெட் ஷெட்யூலர், 'ஹ்ம்ம், இனி புதிய நூல்கள் எதுவும் இல்லை. நாங்கள் வரிசையில் யார் இருக்கிறார்கள்? அதற்கு முன் இடம் கொடுத்தது யார் Thread-2? இருந்ததாகத் தெரிகிறது Thread-1. சரி, நாம் அதை இயக்க அனுமதிக்கிறோம் என்று அர்த்தம். Thread-1அதன் வேலையை முடித்துவிட்டு, நூல் திட்டமிடுபவர் அதன் ஒருங்கிணைப்பைத் தொடர்கிறார்: 'சரி, Thread-1முடிந்தது. வரிசையில் வேறு யாராவது இருக்கிறார்களா?'. த்ரெட்-0 வரிசையில் உள்ளது: அது அதற்கு முன்பே அதன் இடத்தைப் பெற்றதுThread-1. இது இப்போது அதன் முறை மற்றும் நிறைவுக்கு ஓடுகிறது. பின்னர் திட்டமிடுபவர் இழைகளை ஒருங்கிணைத்து முடிக்கிறார்: 'சரி, Thread-2நீங்கள் மற்ற இழைகளுக்கு அடிபணிந்தீர்கள், அவை அனைத்தும் இப்போது முடிந்துவிட்டன. நீங்கள் கடைசியாக விளைந்தீர்கள், இப்போது இது உங்கள் முறை. பின்னர் Thread-2நிறைவுக்கு ஓடுகிறது. கன்சோல் வெளியீடு இப்படி இருக்கும்: Thread-0 அதன் இடத்தை மற்றவர்களுக்கு வழங்குகிறது Thread-1 அதன் இடத்தை மற்றவர்களுக்கு அளிக்கிறது Thread-2 அதன் இடத்தை மற்றவர்களுக்கு வழங்குகிறது Thread-1 செயல்படுத்தி முடிந்தது. Thread-0 செயல்படுத்தப்பட்டது. த்ரெட்-2 செயல்படுத்தி முடிந்தது. நிச்சயமாக, த்ரெட் ஷெட்யூலர் திரிகளை வேறு வரிசையில் தொடங்கலாம் (எடுத்துக்காட்டாக, 0-1-2 க்கு பதிலாக 2-1-0), ஆனால் கொள்கை அப்படியே உள்ளது.

விதிகளுக்கு முன் நடக்கும்

இன்று நாம் தொடும் கடைசி விஷயம், ' முன் நடக்கும் ' என்ற கருத்து. உங்களுக்கு ஏற்கனவே தெரியும், ஜாவாவில் த்ரெட் ஷெட்யூலர் தங்கள் பணிகளைச் செய்ய த்ரெட்களுக்கு நேரத்தையும் வளங்களையும் ஒதுக்குவதில் ஈடுபட்டுள்ள வேலையின் பெரும்பகுதியைச் செய்கிறார். பொதுவாக கணிக்க முடியாத சீரற்ற வரிசையில் நூல்கள் எவ்வாறு செயல்படுத்தப்படுகின்றன என்பதையும் நீங்கள் மீண்டும் மீண்டும் பார்த்திருப்பீர்கள். பொதுவாக, நாம் முன்பு செய்த 'சீக்வென்ஷியல்' புரோகிராமிங்கிற்குப் பிறகு, மல்டித்ரெட் புரோகிராமிங் ஏதோ சீரற்றதாகத் தெரிகிறது. மல்டித்ரெட் செய்யப்பட்ட நிரலின் ஓட்டத்தைக் கட்டுப்படுத்த பல முறைகளைப் பயன்படுத்தலாம் என்று நீங்கள் ஏற்கனவே நம்பிவிட்டீர்கள். ஆனால் ஜாவாவில் மல்டித்ரெடிங்கிற்கு இன்னும் ஒரு தூண் உள்ளது - 4 ' நடக்கும்-முன் ' விதிகள். இந்த விதிகளைப் புரிந்துகொள்வது மிகவும் எளிது. எங்களிடம் இரண்டு நூல்கள் உள்ளன என்று கற்பனை செய்து பாருங்கள் - Aமற்றும்B. இந்த நூல்கள் ஒவ்வொன்றும் செயல்பாடுகளைச் செய்யலாம் 1மற்றும் 2. ஒவ்வொரு விதியிலும், ' A நடக்கும்-முன் B ' என்று கூறும்போது , A​​செயல்பாட்டிற்கு முன் நூல் மூலம் செய்யப்பட்ட அனைத்து மாற்றங்களும் இந்த செயல்பாட்டின் விளைவாக ஏற்படும் மாற்றங்களும் செயல்பாட்டின் போது மற்றும் அதன் பிறகு 1திரிக்கு தெரியும் . நீங்கள் மல்டித்ரெட் செய்யப்பட்ட நிரலை எழுதும்போது, ​​சில நிகழ்வுகள் மற்றவர்களுக்கு 100% நேரத்திற்கு முன்பாக நிகழும் என்றும், செயல்பாட்டின் போது திரியின் செயல்பாட்டின் போது செய்யப்பட்ட மாற்றங்களைப் பற்றி எப்போதும் அறிந்திருக்கும் என்றும் ஒவ்வொரு விதியும் உத்தரவாதம் அளிக்கிறது . அவற்றை மதிப்பாய்வு செய்வோம். B22BA1

விதி 1.

ஒரு மியூடெக்ஸை வெளியிடுவது அதே மானிட்டரை வேறொரு நூலால் பெறுவதற்கு முன்பு நடக்கும் . இங்கே உங்களுக்கு எல்லாம் புரிந்திருக்கும் என்று நினைக்கிறேன். ஒரு பொருளின் அல்லது வகுப்பின் மியூடெக்ஸ் ஒரு நூலால் பெறப்பட்டால், எடுத்துக்காட்டாக, நூல் மூலம் A, மற்றொரு நூலால் (நூல் B) ஒரே நேரத்தில் அதைப் பெற முடியாது. மியூடெக்ஸ் வெளியிடப்படும் வரை அது காத்திருக்க வேண்டும்.

விதி 2.

முறை முன்பு நடக்கும்Thread.start() . மீண்டும், இங்கே கடினமாக எதுவும் இல்லை. முறையின் உள்ளே குறியீட்டை இயக்கத் தொடங்க , நூலில் உள்ள முறையை நீங்கள் அழைக்க வேண்டும் என்பது உங்களுக்கு ஏற்கனவே தெரியும். குறிப்பாக, தொடக்க முறை, முறை அல்ல! அழைக்கப்படுவதற்கு முன் அமைக்கப்பட்ட அனைத்து மாறிகளின் மதிப்புகளும் முறை தொடங்கியவுடன் உள்ளே தெரியும் என்பதை இந்த விதி உறுதி செய்கிறது. Thread.run()run()start()run()Thread.start()run()

விதி 3.

run()முறையின் முடிவு முறையிலிருந்து திரும்புவதற்கு முன் நடக்கும்join() . நமது இரண்டு இழைகளுக்குத் திரும்புவோம்: Aமற்றும் B. இந்த முறையை நாங்கள் அழைக்கிறோம் join(), இதனால் நூல் அதன் வேலையைச் செய்வதற்கு முன் Bநூல் முடிவடையும் வரை காத்திருக்கும் . Aஇதன் பொருள் ஒரு பொருளின் run()முறை இறுதிவரை இயங்கும் என்பது உறுதி. run()மேலும் நூல் முறையில் நடக்கும் தரவுகளில் ஏற்படும் அனைத்து மாற்றங்களும் Aநூலில் தெரியும் என்பது நூறு சதவிகிதம் உத்தரவாதம். Bநூல் அதன் வேலையை முடிக்கும் வரை காத்திருந்து Aஅதன் சொந்த வேலையைத் தொடங்கும்.

விதி 4.

ஒரு volatileமாறிக்கு எழுதுவது அதே மாறியில் இருந்து படிக்கும் முன் நடக்கும் . நாம் முக்கிய சொல்லைப் பயன்படுத்தும் போது volatile, ​​உண்மையில் எப்போதும் தற்போதைய மதிப்பைப் பெறுவோம். ஒரு longஅல்லது double(இங்கே நிகழக்கூடிய பிரச்சனைகள் பற்றி நாங்கள் முன்பு பேசினோம்) நீங்கள் ஏற்கனவே புரிந்து கொண்டபடி, சில தொடரிழைகளில் செய்யப்பட்ட மாற்றங்கள் மற்ற தொடரிழைகளுக்கு எப்போதும் தெரிவதில்லை. ஆனால், நிச்சயமாக, இதுபோன்ற நடத்தை நமக்குப் பொருந்தாத சூழ்நிலைகள் அடிக்கடி உள்ளன. திரியில் ஒரு மாறிக்கு மதிப்பை ஒதுக்குகிறோம் என்று வைத்துக்கொள்வோம் A:

int z;

….

z = 555;

Bஎங்கள் நூல் கன்சோலில் மாறியின் மதிப்பைக் காட்ட வேண்டும் என்றால் z, அது 0 ஐ எளிதாகக் காண்பிக்கும், ஏனெனில் அது ஒதுக்கப்பட்ட மதிப்பைப் பற்றி தெரியாது. zஆனால் விதி 4, நாம் மாறியை என அறிவித்தால் volatile, ஒரு நூலில் அதன் மதிப்பில் ஏற்படும் மாற்றங்கள் மற்றொரு நூலில் எப்போதும் தெரியும் என்று உத்தரவாதம் அளிக்கிறது. volatileமுந்தைய குறியீட்டில் வார்த்தையை சேர்த்தால் ...

volatile int z;

….

z = 555;

B...பின்னர் நூல் 0 ஐக் காட்டக்கூடிய சூழ்நிலையைத் தடுக்கிறோம். volatileமாறிகளுக்கு எழுதுவது அவற்றிலிருந்து படிக்கும் முன் நடக்கும்.