ஒன்றாகச் சிறந்தது: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி II - ஒத்திசைவு

அறிமுகம்

எனவே, ஜாவாவில் நூல்கள் இருப்பதை நாம் அறிவோம். சிறந்த ஒன்றாக: ஜாவா மற்றும் நூல் வகுப்பு என்ற தலைப்பில் நீங்கள் அதைப் பற்றி படிக்கலாம் . பகுதி I - மரணதண்டனையின் நூல்கள் . இணையாக வேலை செய்ய நூல்கள் அவசியம். இது நூல்கள் எப்படியாவது ஒன்றோடு ஒன்று தொடர்பு கொள்ளும் வாய்ப்பு அதிகம். இது எவ்வாறு நிகழ்கிறது மற்றும் எங்களிடம் என்ன அடிப்படை கருவிகள் உள்ளன என்பதைப் பார்ப்போம்.

மகசூல்

Thread.yield() என்பது குழப்பமானது மற்றும் அரிதாகவே பயன்படுத்தப்படுகிறது. இது இணையத்தில் பல வழிகளில் விவரிக்கப்பட்டுள்ளது. சில நூல்களின் வரிசை இருப்பதாக சிலர் எழுதுவது உட்பட, அதில் நூல் முன்னுரிமைகளின் அடிப்படையில் ஒரு நூல் இறங்கும். மற்றவர்கள் ஒரு நூல் அதன் நிலையை "இயங்கும்" என்பதிலிருந்து "இயக்கக்கூடியது" என்று மாற்றும் என்று எழுதுகிறார்கள் (இந்த நிலைகளுக்கு இடையில் வேறுபாடு இல்லை என்றாலும், அதாவது ஜாவா அவற்றை வேறுபடுத்தாது). உண்மை என்னவென்றால், இவை அனைத்தும் மிகவும் குறைவாக அறியப்பட்டவை மற்றும் ஒரு வகையில் எளிமையானவை. ஒரு பிழை உள்ளது ( JDK-6416721: (ஸ்பெக் த்ரெட்) Fix Thread.yield() javadocyield() ) முறையின் ஆவணத்திற்காக உள்நுழைந்துள்ளது . அதைப் படித்தால் தெளிவாகத் தெரியும்yield()இந்த முறையானது ஜாவா த்ரெட் ஷெட்யூலருக்கு சில பரிந்துரைகளை மட்டுமே வழங்குகிறது. ஆனால் உண்மையில் என்ன நடக்கிறது, அதாவது திட்டமிடுபவர் பரிந்துரையின்படி செயல்படுகிறாரா மற்றும் பொதுவாக அது என்ன செய்கிறது என்பது JVM இன் செயல்படுத்தல் மற்றும் இயக்க முறைமையைப் பொறுத்தது. மேலும் இது வேறு சில காரணிகளையும் சார்ந்து இருக்கலாம். ஜாவா மொழி வளர்ச்சியடைந்ததால் மல்டித்ரெடிங் மறுபரிசீலனை செய்யப்பட்டதன் காரணமாக அனைத்து குழப்பங்களும் ஏற்பட வாய்ப்புள்ளது. இங்கே மேலோட்டப் பார்வையில் மேலும் படிக்கவும்: Java Thread.yield() பற்றிய சுருக்கமான அறிமுகம் .

தூங்கு

ஒரு நூல் அதன் செயல்பாட்டின் போது தூங்கலாம். மற்ற இழைகளுடன் தொடர்புகொள்வதற்கான எளிதான வகை இதுவாகும். எங்கள் ஜாவா குறியீட்டை இயக்கும் ஜாவா மெய்நிகர் இயந்திரத்தை இயக்கும் இயக்க முறைமை அதன் சொந்த நூல் திட்டமிடலைக் கொண்டுள்ளது . எந்த நூலை எப்போது தொடங்குவது என்பதை இது தீர்மானிக்கிறது. ஒரு புரோகிராமர் இந்த திட்டமிடலுடன் நேரடியாக ஜாவா குறியீட்டிலிருந்து தொடர்பு கொள்ள முடியாது, JVM மூலம் மட்டுமே. அவர் அல்லது அவள் அட்டவணையை சிறிது நேரம் இடைநிறுத்துமாறு கேட்கலாம், அதாவது அதை தூங்க வைக்கலாம். இந்தக் கட்டுரைகளில் நீங்கள் மேலும் படிக்கலாம்: Thread.sleep() மற்றும் மல்டித்ரெடிங் எவ்வாறு செயல்படுகிறது . விண்டோஸ் இயக்க முறைமைகளில் நூல்கள் எவ்வாறு செயல்படுகின்றன என்பதையும் நீங்கள் பார்க்கலாம்: Windows Thread இன் இன்டர்னல்கள் . இப்போது அதை நம் கண்களால் பார்ப்போம். பின்வரும் குறியீட்டை பெயரிடப்பட்ட கோப்பில் சேமிக்கவும் HelloWorldApp.java:

class HelloWorldApp {
    public static void main(String []args) {
        Runnable task = () -> {
            try {
                int secToWait = 1000 * 60;
                Thread.currentThread().sleep(secToWait);
                System.out.println("Woke up");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Thread thread = new Thread(task);
        thread.start();
    }
}

நீங்கள் பார்க்க முடியும் என, எங்களிடம் 60 வினாடிகள் காத்திருக்கும் சில பணிகள் உள்ளன, அதன் பிறகு நிரல் முடிவடைகிறது. நாங்கள் " " கட்டளையைப் பயன்படுத்தி தொகுத்து javac HelloWorldApp.java, பின்னர் " " ஐப் பயன்படுத்தி நிரலை இயக்குகிறோம் java HelloWorldApp. ஒரு தனி சாளரத்தில் நிரலைத் தொடங்குவது நல்லது. எடுத்துக்காட்டாக, விண்டோஸில், இது போன்றது: start java HelloWorldApp. PID (செயல்முறை ஐடி) பெற jps கட்டளையைப் பயன்படுத்துகிறோம், மேலும் தொடரிழைகளின் பட்டியலை " jvisualvm --openpid pid: நீங்கள் பார்க்கிறபடி, எங்கள் த்ரெட்டில் இப்போது "ஸ்லீப்பிங்" நிலை உள்ளது. உண்மையில், உதவ இன்னும் நேர்த்தியான வழி உள்ளது. எங்கள் நூல் இனிமையான கனவுகள்:

try {
	TimeUnit.SECONDS.sleep(60);
	System.out.println("Woke up");
} catch (InterruptedException e) {
	e.printStackTrace();
}

நாங்கள் எல்லா இடங்களிலும் கையாளுகிறோம் என்பதை நீங்கள் கவனித்தீர்களா InterruptedException? ஏன் என்று புரிந்து கொள்வோம்.

Thread.interrupt()

விஷயம் என்னவென்றால், ஒரு நூல் காத்திருக்கும் / தூங்கும் போது, ​​யாராவது குறுக்கிட விரும்பலாம். இந்த வழக்கில், நாங்கள் கையாளுகிறோம் InterruptedException. Thread.stop()இந்த முறையானது காலாவதியானது மற்றும் விரும்பத்தகாதது என அறிவிக்கப்பட்ட பின்னர் உருவாக்கப்பட்டது . காரணம், stop()முறை அழைக்கப்பட்டபோது, ​​நூல் வெறுமனே "கொல்லப்பட்டது", இது மிகவும் கணிக்க முடியாதது. நூல் எப்போது நிறுத்தப்படும் என்பதை எங்களால் அறிய முடியவில்லை, மேலும் தரவு நிலைத்தன்மைக்கு உத்தரவாதம் அளிக்க முடியவில்லை. நூல் கொல்லப்படும்போது நீங்கள் ஒரு கோப்பில் தரவை எழுதுகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். நூலைக் கொல்வதற்குப் பதிலாக, ஜாவாவின் படைப்பாளிகள் அதை குறுக்கிட வேண்டும் என்று சொல்வது மிகவும் தர்க்கரீதியானதாக இருக்கும் என்று முடிவு செய்தனர். இந்தத் தகவலுக்கு எவ்வாறு பதிலளிப்பது என்பது திரியே முடிவு செய்ய வேண்டிய விஷயம். மேலும் விவரங்களுக்கு, Thread.stop ஏன் நிறுத்தப்பட்டது?ஆரக்கிளின் இணையதளத்தில். ஒரு உதாரணத்தைப் பார்ப்போம்:

public static void main(String []args) {
	Runnable task = () -> {
		try {
			TimeUnit.SECONDS.sleep(60);
		} catch (InterruptedException e) {
			System.out.println("Interrupted");
		}
	};
	Thread thread = new Thread(task);
	thread.start();
	thread.interrupt();
}

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

public static void main(String []args) {
	Runnable task = () -> {
		while(!Thread.currentThread().isInterrupted()) {
			// Do some work
		}
		System.out.println("Finished");
	};
	Thread thread = new Thread(task);
	thread.start();
	thread.interrupt();
}

மேலே உள்ள எடுத்துக்காட்டில், whileநூல் வெளிப்புறமாக குறுக்கிடப்படும் வரை லூப் செயல்படுத்தப்படும். கொடியைப் பொறுத்தவரை , , isInterrupted கொடி மீட்டமைக்கப்படும், பின்னர் தவறானதாகத் திரும்பும் என்பதை isInterruptedஅறிந்து கொள்வது அவசியம் . த்ரெட் வகுப்பில் நிலையான Thread.interrupted() முறையும் உள்ளது, இது தற்போதைய தொடரிழைக்கு மட்டுமே பொருந்தும், ஆனால் இந்த முறையானது கொடியை தவறு என மீட்டமைக்கிறது! நூல் குறுக்கீடு என்ற தலைப்பில் இந்த அத்தியாயத்தில் மேலும் படிக்கவும் . InterruptedExceptionisInterrupted()

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

எளிமையான வகை காத்திருப்பு மற்றொரு நூல் முடிவடையும் வரை காத்திருக்கிறது.

public static void main(String []args) throws InterruptedException {
	Runnable task = () -> {
		try {
			TimeUnit.SECONDS.sleep(5);
		} catch (InterruptedException e) {
			System.out.println("Interrupted");
		}
	};
	Thread thread = new Thread(task);
	thread.start();
	thread.join();
	System.out.println("Finished");
}

இந்த எடுத்துக்காட்டில், புதிய நூல் 5 வினாடிகள் தூங்கும். அதே நேரத்தில், தூங்கும் நூல் எழுந்து அதன் வேலையை முடிக்கும் வரை பிரதான நூல் காத்திருக்கும். JVisualVM இல் நூலின் நிலையைப் பார்த்தால், அது இப்படி இருக்கும்: கண்காணிப்புக் கருவிகளுக்கு நன்றி, நூலில் என்ன நடக்கிறது என்பதை நீங்கள் பார்க்கலாம். இந்த joinமுறை மிகவும் எளிமையானது, ஏனெனில் இது ஜாவா குறியீட்டைக் கொண்ட ஒரு முறையாகும், wait()அது அழைக்கப்படும் நூல் உயிருடன் இருக்கும் வரை இயங்கும். நூல் இறந்தவுடன் (அதன் வேலை முடிந்ததும்), காத்திருப்பு குறுக்கிடப்படுகிறது. மேலும் அந்த முறையின் மந்திரம் அவ்வளவுதான் join(). எனவே, மிகவும் சுவாரஸ்யமான விஷயத்திற்கு செல்லலாம்.

கண்காணிக்கவும்

மல்டித்ரெடிங் ஒரு மானிட்டர் என்ற கருத்தை உள்ளடக்கியது. மானிட்டர் என்ற சொல் 16 ஆம் நூற்றாண்டின் லத்தீன் மொழியில் ஆங்கிலத்திற்கு வந்தது மற்றும் "ஒரு செயல்முறையின் தொடர்ச்சியான பதிவை கவனிக்க, சரிபார்க்க அல்லது வைத்திருக்க பயன்படும் கருவி அல்லது சாதனம்" என்று பொருள். இந்த கட்டுரையின் சூழலில், அடிப்படைகளை மறைக்க முயற்சிப்போம். விவரங்கள் விரும்பும் எவருக்கும், இணைக்கப்பட்ட பொருட்களுக்கு முழுக்கு செய்யவும். ஜாவா மொழி விவரக்குறிப்புடன் (JLS) எங்கள் பயணத்தைத் தொடங்குகிறோம்: 17.1. ஒத்திசைவு . இது பின்வருவனவற்றைக் கூறுகிறது: நூல்களுக்கு இடையில் ஒத்திசைக்க ஜாவா ஒரு "மானிட்டர்" பொறிமுறையைப் பயன்படுத்துகிறது. ஒவ்வொரு பொருளுடனும் ஒரு மானிட்டர் தொடர்புடையது, மேலும் நூல்கள் அதை உடன் பெறலாம் lock()அல்லது வெளியிடலாம் unlock(). அடுத்து, ஆரக்கிள் இணையதளத்தில் டுடோரியலைக் காண்போம்: உள்ளார்ந்த பூட்டுகள் மற்றும் ஒத்திசைவு. ஜாவாவின் ஒத்திசைவு ஒரு உள்ளார்ந்த பூட்டு அல்லது மானிட்டர் பூட்டு எனப்படும் உள் நிறுவனத்தைச் சுற்றி கட்டமைக்கப்பட்டுள்ளது என்று இந்தப் பயிற்சி கூறுகிறது . இந்த பூட்டு பெரும்பாலும் " மானிட்டர் " என்று அழைக்கப்படுகிறது. ஜாவாவில் உள்ள ஒவ்வொரு பொருளுக்கும் அதனுடன் தொடர்புடைய ஒரு உள்ளார்ந்த பூட்டு இருப்பதையும் மீண்டும் பார்க்கிறோம். நீங்கள் ஜாவாவைப் படிக்கலாம் - உள்ளார்ந்த பூட்டுகள் மற்றும் ஒத்திசைவு . அடுத்து ஜாவாவில் உள்ள ஒரு பொருளை மானிட்டருடன் எவ்வாறு தொடர்புபடுத்த முடியும் என்பதைப் புரிந்துகொள்வது முக்கியம். ஜாவாவில், ஒவ்வொரு பொருளுக்கும் ஒரு தலைப்பு உள்ளது, இது குறியீட்டிலிருந்து புரோகிராமருக்கு கிடைக்காத உள் மெட்டாடேட்டாவை சேமிக்கிறது, ஆனால் மெய்நிகர் இயந்திரம் பொருள்களுடன் சரியாக வேலை செய்ய வேண்டும். பொருள் தலைப்பில் "குறிச்சொல் வார்த்தை" உள்ளது, இது போல் தெரிகிறது:

https://edu.netbeans.org/contrib/slides/java-overview-and-java-se6.pdf

மிகவும் பயனுள்ள ஒரு JavaWorld கட்டுரை இங்கே உள்ளது: ஜாவா மெய்நிகர் இயந்திரம் நூல் ஒத்திசைவை எவ்வாறு செய்கிறது . JDK பிழை-கண்காணிப்பு அமைப்பில் பின்வரும் இதழின் "சுருக்கம்" பகுதியின் விளக்கத்துடன் இந்தக் கட்டுரை இணைக்கப்பட வேண்டும்: JDK-8183909 . நீங்கள் அதை இங்கே படிக்கலாம்: JEP-8183909 . எனவே, ஜாவாவில், ஒரு மானிட்டர் ஒரு பொருளுடன் தொடர்புடையது மற்றும் நூல் பூட்டைப் பெற (அல்லது பெற) முயற்சிக்கும் போது ஒரு நூலைத் தடுக்கப் பயன்படுகிறது. இங்கே எளிய உதாரணம்:

public class HelloWorld{
    public static void main(String []args){
        Object object = new Object();
        synchronized(object) {
            System.out.println("Hello World");
        }
    }
}

இங்கே, தற்போதைய நூல் (இந்தக் குறியீடுகளின் வரிகள் செயல்படுத்தப்படும்) synchronizedமுக்கிய சொல்லைப் பயன்படுத்தி தொடர்புடைய மானிட்டரைப் பயன்படுத்த முயற்சிக்கிறதுobject"\பூட்டைப் பெற/பெற மாறி. மானிட்டருக்காக வேறு யாரும் போட்டியிடவில்லை என்றால் (அதாவது வேறு யாரும் ஒரே பொருளைப் பயன்படுத்தி ஒத்திசைக்கப்பட்ட குறியீட்டை இயக்கவில்லை), ஜாவா "சார்பு பூட்டுதல்" எனப்படும் மேம்படுத்தலைச் செய்ய முயற்சி செய்யலாம். ஒரு தொடர்புடைய குறிச்சொல் மற்றும் மானிட்டரின் பூட்டு எந்த நூலுக்குச் சொந்தமானது என்பது பற்றிய பதிவும் பொருள் தலைப்பில் உள்ள குறிச்சொல்லில் சேர்க்கப்படும். இது மானிட்டரைப் பூட்டுவதற்குத் தேவைப்படும் மேல்நிலையைக் குறைக்கிறது. மானிட்டர் முன்பு வேறொரு நூலுக்குச் சொந்தமானதாக இருந்தால், அத்தகைய பூட்டுதல் போதாது. JVM அடுத்த வகை பூட்டலுக்கு மாறுகிறது: "அடிப்படை பூட்டுதல்". இது ஒப்பீடு மற்றும் இடமாற்று (CAS) செயல்பாடுகளைப் பயன்படுத்துகிறது. மேலும் என்னவென்றால், ஆப்ஜெக்ட் ஹெடரின் மார்க் வார்த்தையே குறிச்சொல்லைச் சேமிக்காது, மாறாக அது எங்கே சேமிக்கப்படுகிறது என்பதைக் குறிப்பிடுகிறது, மேலும் டேக் மாறுகிறது, இதனால் நாம் அடிப்படை பூட்டுதலைப் பயன்படுத்துகிறோம் என்பதை JVM புரிந்துகொள்ளும். ஒரு மானிட்டருக்குப் பல த்ரெட்கள் போட்டியிட்டால் (ஒருவர் பூட்டைப் பெற்றுள்ளார், மேலும் ஒரு வினாடி பூட்டு வெளியிடப்படுவதற்குக் காத்திருக்கிறது), பின்னர் குறிச்சொல்லில் உள்ள குறிச்சொல் மாறுகிறது, மேலும் மார்க் வார்த்தை இப்போது மானிட்டரைப் பற்றிய குறிப்பைச் சேமிக்கும் ஒரு பொருளாக — JVM இன் சில உள் நிறுவனம். JDK ஊக்கமளிக்கும் முன்மொழிவில் (JEP) கூறப்பட்டுள்ளபடி, இந்த நிலையைச் சேமிப்பதற்காக நினைவகத்தின் நேட்டிவ் ஹீப் பகுதியில் இடம் தேவைப்படுகிறது. இந்த அக உட்பொருளின் நினைவக இருப்பிடம் பற்றிய குறிப்பு, பொருள் தலைப்பின் குறிச்சொல்லில் சேமிக்கப்படும். எனவே, ஒரு மானிட்டர் உண்மையில் பல நூல்களில் பகிரப்பட்ட ஆதாரங்களுக்கான அணுகலை ஒத்திசைப்பதற்கான ஒரு பொறிமுறையாகும். இந்த பொறிமுறையின் பல செயலாக்கங்களுக்கு இடையே JVM மாறுகிறது. எனவே, எளிமைக்காக, மானிட்டரைப் பற்றி பேசுகையில், நாங்கள் உண்மையில் பூட்டுகளைப் பற்றி பேசுகிறோம். மற்றும் பூட்டு வெளியிடப்படுவதற்கு ஒரு வினாடி காத்திருக்கிறது), பின்னர் குறிச்சொல்லில் உள்ள குறிச்சொல் மாறுகிறது, மேலும் மார்க் வார்த்தை இப்போது மானிட்டரை ஒரு பொருளாகக் குறிப்பிடுகிறது - JVM இன் சில உள் நிறுவனம். JDK ஊக்கமளிக்கும் முன்மொழிவில் (JEP) கூறப்பட்டுள்ளபடி, இந்த நிலையைச் சேமிப்பதற்காக நினைவகத்தின் நேட்டிவ் ஹீப் பகுதியில் இடம் தேவைப்படுகிறது. இந்த அக உட்பொருளின் நினைவக இருப்பிடம் பற்றிய குறிப்பு, பொருள் தலைப்பின் குறிச்சொல்லில் சேமிக்கப்படும். எனவே, ஒரு மானிட்டர் உண்மையில் பல நூல்களில் பகிரப்பட்ட ஆதாரங்களுக்கான அணுகலை ஒத்திசைப்பதற்கான ஒரு பொறிமுறையாகும். இந்த பொறிமுறையின் பல செயலாக்கங்களுக்கு இடையே JVM மாறுகிறது. எனவே, எளிமைக்காக, மானிட்டரைப் பற்றி பேசுகையில், நாங்கள் உண்மையில் பூட்டுகளைப் பற்றி பேசுகிறோம். மற்றும் பூட்டு வெளியிடப்படுவதற்கு ஒரு வினாடி காத்திருக்கிறது), பின்னர் குறிச்சொல்லில் உள்ள குறிச்சொல் மாறுகிறது, மேலும் மார்க் வார்த்தை இப்போது மானிட்டரை ஒரு பொருளாகக் குறிப்பிடுகிறது - JVM இன் சில உள் நிறுவனம். JDK ஊக்கமளிக்கும் முன்மொழிவில் (JEP) கூறப்பட்டுள்ளபடி, இந்த நிலையைச் சேமிப்பதற்காக நினைவகத்தின் நேட்டிவ் ஹீப் பகுதியில் இடம் தேவைப்படுகிறது. இந்த அக உட்பொருளின் நினைவக இருப்பிடம் பற்றிய குறிப்பு, பொருள் தலைப்பின் குறிச்சொல்லில் சேமிக்கப்படும். எனவே, ஒரு மானிட்டர் உண்மையில் பல நூல்களில் பகிரப்பட்ட ஆதாரங்களுக்கான அணுகலை ஒத்திசைப்பதற்கான ஒரு பொறிமுறையாகும். இந்த பொறிமுறையின் பல செயலாக்கங்களுக்கு இடையே JVM மாறுகிறது. எனவே, எளிமைக்காக, மானிட்டரைப் பற்றி பேசுகையில், நாங்கள் உண்மையில் பூட்டுகளைப் பற்றி பேசுகிறோம். மற்றும் மார்க் சொல் இப்போது மானிட்டரை ஒரு பொருளாகக் குறிப்பிடுகிறது - JVM இன் சில உள் நிறுவனம். JDK ஊக்கமளிக்கும் முன்மொழிவில் (JEP) கூறப்பட்டுள்ளபடி, இந்த நிலையைச் சேமிப்பதற்காக நினைவகத்தின் நேட்டிவ் ஹீப் பகுதியில் இடம் தேவைப்படுகிறது. இந்த அக உட்பொருளின் நினைவக இருப்பிடம் பற்றிய குறிப்பு, பொருள் தலைப்பின் குறிச்சொல்லில் சேமிக்கப்படும். எனவே, ஒரு மானிட்டர் உண்மையில் பல நூல்களில் பகிரப்பட்ட ஆதாரங்களுக்கான அணுகலை ஒத்திசைப்பதற்கான ஒரு பொறிமுறையாகும். இந்த பொறிமுறையின் பல செயலாக்கங்களுக்கு இடையே JVM மாறுகிறது. எனவே, எளிமைக்காக, மானிட்டரைப் பற்றி பேசுகையில், நாங்கள் உண்மையில் பூட்டுகளைப் பற்றி பேசுகிறோம். மற்றும் மார்க் சொல் இப்போது மானிட்டரை ஒரு பொருளாகக் குறிப்பிடுகிறது - JVM இன் சில உள் நிறுவனம். JDK ஊக்கமளிக்கும் முன்மொழிவில் (JEP) கூறப்பட்டுள்ளபடி, இந்த நிலையைச் சேமிப்பதற்காக நினைவகத்தின் நேட்டிவ் ஹீப் பகுதியில் இடம் தேவைப்படுகிறது. இந்த அக உட்பொருளின் நினைவக இருப்பிடம் பற்றிய குறிப்பு, பொருள் தலைப்பின் குறிச்சொல்லில் சேமிக்கப்படும். எனவே, ஒரு மானிட்டர் உண்மையில் பல நூல்களில் பகிரப்பட்ட ஆதாரங்களுக்கான அணுகலை ஒத்திசைப்பதற்கான ஒரு பொறிமுறையாகும். இந்த பொறிமுறையின் பல செயலாக்கங்களுக்கு இடையே JVM மாறுகிறது. எனவே, எளிமைக்காக, மானிட்டரைப் பற்றி பேசுகையில், நாங்கள் உண்மையில் பூட்டுகளைப் பற்றி பேசுகிறோம். இந்த அக உட்பொருளின் நினைவக இருப்பிடம் பற்றிய குறிப்பு, பொருள் தலைப்பின் குறிச்சொல்லில் சேமிக்கப்படும். எனவே, ஒரு மானிட்டர் உண்மையில் பல நூல்களில் பகிரப்பட்ட ஆதாரங்களுக்கான அணுகலை ஒத்திசைப்பதற்கான ஒரு பொறிமுறையாகும். இந்த பொறிமுறையின் பல செயலாக்கங்களுக்கு இடையே JVM மாறுகிறது. எனவே, எளிமைக்காக, மானிட்டரைப் பற்றி பேசுகையில், நாங்கள் உண்மையில் பூட்டுகளைப் பற்றி பேசுகிறோம். இந்த அக உட்பொருளின் நினைவக இருப்பிடம் பற்றிய குறிப்பு, பொருள் தலைப்பின் குறிச்சொல்லில் சேமிக்கப்படும். எனவே, ஒரு மானிட்டர் உண்மையில் பல நூல்களில் பகிரப்பட்ட ஆதாரங்களுக்கான அணுகலை ஒத்திசைப்பதற்கான ஒரு பொறிமுறையாகும். இந்த பொறிமுறையின் பல செயலாக்கங்களுக்கு இடையே JVM மாறுகிறது. எனவே, எளிமைக்காக, மானிட்டரைப் பற்றி பேசுகையில், நாங்கள் உண்மையில் பூட்டுகளைப் பற்றி பேசுகிறோம்.

ஒத்திசைக்கப்பட்டது (பூட்டுக்காக காத்திருக்கிறது)

நாம் முன்பு பார்த்தது போல், "ஒத்திசைக்கப்பட்ட தொகுதி" (அல்லது "முக்கியமான பகுதி") என்ற கருத்து ஒரு மானிட்டரின் கருத்துடன் நெருக்கமாக தொடர்புடையது. ஒரு உதாரணத்தைப் பாருங்கள்:

public static void main(String[] args) throws InterruptedException {
	Object lock = new Object();

	Runnable task = () -> {
		synchronized(lock) {
			System.out.println("thread");
		}
	};

	Thread th1 = new Thread(task);
	th1.start();
	synchronized(lock) {
		for (int i = 0; i < 8; i++) {
			Thread.currentThread().sleep(1000);
			System.out.print(" " + i);
		}
		System.out.println(" ...");
	}
}

இங்கே, பிரதான நூல் முதலில் பணிப் பொருளை புதிய நூலுக்கு அனுப்புகிறது, பின்னர் உடனடியாக பூட்டைப் பெற்று அதனுடன் ஒரு நீண்ட செயல்பாட்டைச் செய்கிறது (8 வினாடிகள்). இந்த நேரத்தில், பணி தொடர முடியவில்லை, ஏனெனில் அது தொகுதிக்குள் நுழைய முடியாது synchronized, ஏனெனில் பூட்டு ஏற்கனவே வாங்கியது. நூல் பூட்டைப் பெற முடியாவிட்டால், அது மானிட்டருக்கு காத்திருக்கும். பூட்டைப் பெற்றவுடன், அது தொடர்ந்து செயல்படுத்தப்படும். ஒரு நூல் மானிட்டரிலிருந்து வெளியேறும் போது, ​​அது பூட்டை வெளியிடுகிறது. JVisualVM இல், இது போல் தெரிகிறது: JVisualVM இல் நீங்கள் பார்ப்பது போல், நிலை "மானிட்டர்" ஆகும், அதாவது நூல் தடுக்கப்பட்டுள்ளது மற்றும் மானிட்டரை எடுக்க முடியாது. நூலின் நிலையைத் தீர்மானிக்க நீங்கள் குறியீட்டைப் பயன்படுத்தலாம், ஆனால் இந்த வழியில் தீர்மானிக்கப்படும் நிலையின் பெயர்கள் JVisualVM இல் பயன்படுத்தப்படும் பெயர்களுடன் பொருந்தவில்லை, இருப்பினும் அவை ஒத்ததாக இருக்கும். இந்நிலையில், திth1.getState()for loop இல் உள்ள ஸ்டேட்மென்ட் BLOCKed என்று திரும்பும் , ஏனெனில் லூப் இயங்கும் வரை, lockபொருளின் மானிட்டர் நூலால் ஆக்கிரமிக்கப்படும் main, மேலும் th1நூல் தடுக்கப்பட்டு பூட்டு வெளியிடப்படும் வரை தொடர முடியாது. ஒத்திசைக்கப்பட்ட தொகுதிகள் கூடுதலாக, ஒரு முழு முறையையும் ஒத்திசைக்க முடியும். எடுத்துக்காட்டாக, வகுப்பிலிருந்து ஒரு முறை இங்கே HashTable:

public synchronized int size() {
	return count;
}

இந்த முறை எந்த நேரத்திலும் ஒரு நூல் மூலம் மட்டுமே செயல்படுத்தப்படும். நமக்கு உண்மையிலேயே பூட்டு தேவையா? ஆம், எங்களுக்கு அது தேவை. நிகழ்வு முறைகளின் விஷயத்தில், "இந்த" பொருள் (தற்போதைய பொருள்) ஒரு பூட்டாக செயல்படுகிறது. இந்த தலைப்பில் ஒரு சுவாரஸ்யமான விவாதம் இங்கே உள்ளது: ஒத்திசைக்கப்பட்ட தொகுதிக்குப் பதிலாக ஒத்திசைக்கப்பட்ட முறையைப் பயன்படுத்துவதில் நன்மை உள்ளதா? . முறை நிலையானதாக இருந்தால், பூட்டு "இந்த" பொருளாக இருக்காது (ஏனென்றால் நிலையான முறைக்கு "இந்த" பொருள் இல்லை), மாறாக ஒரு வகுப்பு பொருள் (உதாரணமாக, ) Integer.class.

காத்திருங்கள் (மானிட்டருக்காக காத்திருக்கிறது). notify() மற்றும் notifyAll() முறைகள்

த்ரெட் வகுப்பில் மற்றொரு காத்திருப்பு முறை உள்ளது, அது மானிட்டருடன் தொடர்புடையது. sleep()மற்றும் போலல்லாமல் join(), இந்த முறையை வெறுமனே அழைக்க முடியாது. அதன் பெயர் wait(). waitநாம் காத்திருக்க விரும்பும் மானிட்டருடன் தொடர்புடைய பொருளின் மீது இந்த முறை அழைக்கப்படுகிறது. ஒரு உதாரணத்தைப் பார்ப்போம்:

public static void main(String []args) throws InterruptedException {
	    Object lock = new Object();
	    // The task object will wait until it is notified via lock
	    Runnable task = () -> {
	        synchronized(lock) {
	            try {
	                lock.wait();
	            } catch(InterruptedException e) {
	                System.out.println("interrupted");
	            }
	        }
	        // After we are notified, we will wait until we can acquire the lock
	        System.out.println("thread");
	    };
	    Thread taskThread = new Thread(task);
	    taskThread.start();
        // We sleep. Then we acquire the lock, notify, and release the lock
	    Thread.currentThread().sleep(3000);
	    System.out.println("main");
	    synchronized(lock) {
	        lock.notify();
	    }
}

JVisualVM இல், இது போல் தெரிகிறது: இது எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்து கொள்ள, wait()மற்றும் notify()முறைகள் உடன் தொடர்புடையவை என்பதை நினைவில் கொள்ளுங்கள் java.lang.Object. நூல் தொடர்பான முறைகள் வகுப்பில் இருப்பது விசித்திரமாகத் தோன்றலாம் Object. ஆனால் அதற்கான காரணம் தற்போது வெளியாகியுள்ளது. ஜாவாவில் உள்ள ஒவ்வொரு பொருளுக்கும் ஒரு தலைப்பு இருப்பதை நீங்கள் நினைவில் கொள்வீர்கள். தலைப்பில் மானிட்டரைப் பற்றிய தகவல்கள், அதாவது பூட்டின் நிலை உள்ளிட்ட பல்வேறு வீட்டு பராமரிப்புத் தகவல்கள் உள்ளன. நினைவில் கொள்ளுங்கள், ஒவ்வொரு பொருளும் அல்லது ஒரு வகுப்பின் நிகழ்வும், JVM இல் உள்ள ஒரு உள் நிறுவனத்துடன் தொடர்புடையது, இது ஒரு உள்ளார்ந்த பூட்டு அல்லது மானிட்டர் என்று அழைக்கப்படுகிறது. மேலே உள்ள எடுத்துக்காட்டில், பணி பொருளுக்கான குறியீடு, பொருளுடன் தொடர்புடைய மானிட்டருக்கான ஒத்திசைக்கப்பட்ட தொகுதியை உள்ளிடுகிறோம் என்பதைக் குறிக்கிறது lock. இந்த மானிட்டருக்கான பூட்டைப் பெறுவதில் நாம் வெற்றி பெற்றால், பிறகுwait()அழைக்கப்படுகிறது. பணியைச் செயல்படுத்தும் நூல் பொருளின் மானிட்டரை வெளியிடும் , ஆனால் பொருளின் மானிட்டரிடமிருந்து lockஅறிவிப்புக்காக காத்திருக்கும் நூல்களின் வரிசையில் நுழையும் . lockஇந்த நூல்களின் வரிசை WAIT SET என அழைக்கப்படுகிறது, இது அதன் நோக்கத்தை இன்னும் சரியாக பிரதிபலிக்கிறது. அதாவது, இது ஒரு வரிசையை விட ஒரு செட் ஆகும். நூல் mainபணிப் பொருளுடன் புதிய நூலை உருவாக்கி, அதைத் தொடங்கி, 3 வினாடிகள் காத்திருக்கிறது. இது புதிய தொடரிழை நூலுக்கு முன் பூட்டைப் பெற்று main, மானிட்டரின் வரிசையில் வருவதற்கான வாய்ப்புகளை அதிகமாக்குகிறது. அதன் பிறகு, mainநூலே பொருளின் ஒத்திசைக்கப்பட்ட தொகுதிக்குள் நுழைந்து lockமானிட்டரைப் பயன்படுத்தி நூல் அறிவிப்பைச் செய்கிறது. அறிவிப்பு அனுப்பப்பட்ட பிறகு, mainநூல் வெளியிடுகிறதுlocklockஆப்ஜெக்ட்டின் மானிட்டர் மற்றும் புதிய த்ரெட், அப்ஜெக்ட்டின் மானிட்டர் வெளியிடப்படுவதற்கு முன்பு காத்திருந்தது , தொடர்ந்து செயல்படுத்தப்படுகிறது. notify()ஒரே ஒரு தொடரிழைக்கு ( ) அல்லது ஒரே நேரத்தில் ( ) வரிசையில் உள்ள அனைத்து தொடரிழைகளுக்கும் அறிவிப்பை அனுப்ப முடியும் notifyAll(). மேலும் இங்கே படிக்கவும்: ஜாவாவில் notify() மற்றும் notifyAll() இடையே உள்ள வேறுபாடு . JVM எவ்வாறு செயல்படுத்தப்படுகிறது என்பதைப் பொறுத்தே அறிவிப்பு ஆர்டர் அமையும் என்பதைக் கவனத்தில் கொள்ள வேண்டும். மேலும் இங்கே படிக்கவும்: அனைவருக்கும் அறிவித்தல் மற்றும் அறிவிப்பதன் மூலம் பட்டினியை எவ்வாறு தீர்ப்பது? . ஒரு பொருளைக் குறிப்பிடாமல் ஒத்திசைவு செய்ய முடியும். குறியீட்டின் ஒரு தொகுதியை விட முழு முறையும் ஒத்திசைக்கப்படும் போது நீங்கள் இதைச் செய்யலாம். எடுத்துக்காட்டாக, நிலையான முறைகளுக்கு, பூட்டு ஒரு வகுப்பு பொருளாக இருக்கும் (வழியாக பெறப்பட்டது .class):

public static synchronized void printA() {
	System.out.println("A");
}
public static void printB() {
	synchronized(HelloWorld.class) {
		System.out.println("B");
	}
}

பூட்டுகளைப் பயன்படுத்துவதைப் பொறுத்தவரை, இரண்டு முறைகளும் ஒரே மாதிரியானவை. ஒரு முறை நிலையானதாக இல்லாவிட்டால், தற்போதைய மின்னோட்டத்தைப் பயன்படுத்தி ஒத்திசைவு செய்யப்படும் instance, அதாவது this. மூலம், getState()ஒரு நூலின் நிலையைப் பெற நீங்கள் முறையைப் பயன்படுத்தலாம் என்று நாங்கள் முன்பே சொன்னோம். எடுத்துக்காட்டாக, மானிட்டருக்காகக் காத்திருக்கும் வரிசையில் உள்ள தொடரிழைக்கு, முறையானது wait()காலக்கெடுவைக் குறிப்பிட்டால், நிலை காத்திருக்கிறது அல்லது TIMED_WAITING ஆக இருக்கும்.

https://stackoverflow.com/questions/36425942/what-is-the-lifecycle-of-thread-in-java

நூல் வாழ்க்கை சுழற்சி

அதன் வாழ்நாளில், ஒரு நூலின் நிலை மாறுகிறது. உண்மையில், இந்த மாற்றங்கள் நூலின் வாழ்க்கைச் சுழற்சியை உள்ளடக்கியது. ஒரு நூல் உருவாக்கப்பட்டவுடன், அதன் நிலை புதியது. இந்த நிலையில், புதிய த்ரெட் இன்னும் இயங்கவில்லை மற்றும் ஜாவா த்ரெட் ஷெட்யூலருக்கு இது பற்றி எதுவும் தெரியவில்லை. த்ரெட் ஷெட்யூலர் நூலைப் பற்றி அறிய, நீங்கள் thread.start()முறையை அழைக்க வேண்டும். பின்னர் நூல் இயங்கக்கூடிய நிலைக்கு மாறும். இணையத்தில் "இயக்கக்கூடிய" மற்றும் "இயக்கும்" நிலைகளை வேறுபடுத்தும் தவறான வரைபடங்கள் நிறைய உள்ளன. ஆனால் இது ஒரு தவறு, ஏனென்றால் ஜாவா "வேலை செய்யத் தயார்" (இயக்கக்கூடியது) மற்றும் "வேலை செய்வது" (இயங்கும்) ஆகியவற்றுக்கு இடையே வேறுபடுத்திக் காட்டவில்லை. ஒரு நூல் உயிருடன் இருந்தாலும் செயலில் இல்லாதபோது (இயக்க முடியாதது), அது இரண்டு நிலைகளில் ஒன்றில் இருக்கும்:

• Blocked — ஒரு முக்கியமான பிரிவில் நுழைய காத்திருக்கிறது, அதாவது ஒரு synchronizedதொகுதி.
• காத்திருத்தல் — சில நிபந்தனைகளை பூர்த்தி செய்ய மற்றொரு நூல் காத்திருக்கிறது.

நிபந்தனை திருப்தி அடைந்தால், த்ரெட் ஷெட்யூலர் நூலைத் தொடங்குகிறார். த்ரெட் ஒரு குறிப்பிட்ட நேரம் வரை காத்திருந்தால், அதன் நிலை TIMED_WAITING. நூல் இனி இயங்கவில்லை என்றால் (அது முடிந்தது அல்லது விதிவிலக்கு போடப்பட்டது), பின்னர் அது TERMINATED நிலைக்கு நுழைகிறது. நூலின் நிலையை அறிய, getState()முறையைப் பயன்படுத்தவும். த்ரெட்களுக்கு ஒரு isAlive()முறை உள்ளது, இது த்ரெட் டெர்மினேட் செய்யப்படாவிட்டால் அது உண்மையாக இருக்கும்.

பூட்டு ஆதரவு மற்றும் நூல் பார்க்கிங்

ஜாவா 1.6 இல் தொடங்கி, LockSupport எனப்படும் ஒரு சுவாரசியமான பொறிமுறை தோன்றியது. இந்த வகுப்பு, அதைப் பயன்படுத்தும் ஒவ்வொரு நூலுடனும் "அனுமதி"யை இணைக்கிறது. அனுமதி கிடைத்தால் முறைக்கான அழைப்பு park()உடனடியாகத் திரும்பும், செயல்பாட்டில் அனுமதியைப் பயன்படுத்துகிறது. இல்லையெனில், அது தடுக்கிறது. முறைக்கு அழைப்பது unparkஇன்னும் கிடைக்கவில்லை என்றால் அனுமதி கிடைக்கும். 1 அனுமதி மட்டுமே உள்ளது. ஜாவா ஆவணம் LockSupportவகுப்பைக் குறிக்கிறது Semaphore. ஒரு எளிய உதாரணத்தைப் பார்ப்போம்:

import java.util.concurrent.Semaphore;
public class HelloWorldApp{
    
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(0);
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            // Request the permit and wait until we get it
            e.printStackTrace();
        }
        System.out.println("Hello, World!");
    }
}

இந்த குறியீடு எப்போதும் காத்திருக்கும், ஏனெனில் இப்போது செமாஃபோருக்கு 0 அனுமதிகள் உள்ளன. acquire()குறியீட்டில் அழைக்கப்படும் போது (அதாவது அனுமதியைக் கோருங்கள்), அனுமதி பெறும் வரை நூல் காத்திருக்கிறது. நாங்கள் காத்திருக்கிறோம் என்பதால், நாம் கையாள வேண்டும் InterruptedException. சுவாரஸ்யமாக, செமாஃபோர் ஒரு தனி நூல் நிலையைப் பெறுகிறது. JVisualVM இல் பார்த்தால், மாநிலம் "காத்திருங்கள்" அல்ல, ஆனால் "பூங்கா" என்று தெரியும். மற்றொரு உதாரணத்தைப் பார்ப்போம்:

public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            // Park the current thread
            System.err.println("Will be Parked");
            LockSupport.park();
            // As soon as we are unparked, we will start to act
            System.err.println("Unparked");
        };
        Thread th = new Thread(task);
        th.start();
        Thread.currentThread().sleep(2000);
        System.err.println("Thread state: " + th.getState());
        
        LockSupport.unpark(th);
        Thread.currentThread().sleep(2000);
}

தொடரின் நிலை காத்திருக்கும், ஆனால் JVisualVM முக்கிய சொல்லிலிருந்தும் waitவகுப்பிலிருந்தும் வேறுபடுத்துகிறது . இது ஏன் மிகவும் முக்கியமானது? நாங்கள் மீண்டும் ஜாவா ஆவணத்திற்குத் திரும்பி, காத்திருக்கும் நூல் நிலையைப் பார்க்கிறோம். நீங்கள் பார்க்க முடியும் என, அதில் நுழைவதற்கு மூன்று வழிகள் மட்டுமே உள்ளன. அவற்றில் இரண்டு வழிகள் மற்றும் . மற்றும் மூன்றாவது . ஜாவாவில், பூட்டுகள் t இல் உருவாக்கப்படலாம் மற்றும் உயர்-நிலை கருவிகளை வழங்குகின்றன. ஒன்றைப் பயன்படுத்த முயற்சிப்போம். உதாரணமாக, பாருங்கள் : synchronizedparkLockSupportLockSupportwait()join()LockSupportLockSupporReentrantLock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class HelloWorld{

    public static void main(String []args) throws InterruptedException {
        Lock lock = new ReentrantLock();
        Runnable task = () -> {
            lock.lock();
            System.out.println("Thread");
            lock.unlock();
        };
        lock.lock();

        Thread th = new Thread(task);
        th.start();
        System.out.println("main");
        Thread.currentThread().sleep(2000);
        lock.unlock();
    }
}

முந்தைய எடுத்துக்காட்டுகளைப் போலவே, இங்கே எல்லாம் எளிது. lockபகிரப்பட்ட ஆதாரத்தை யாராவது வெளியிடுவதற்காக பொருள் காத்திருக்கிறது . mainநாம் JVisualVM இல் பார்த்தால், நூல் பூட்டை வெளியிடும் வரை புதிய நூல் நிறுத்தப்பட்டிருப்பதைக் காண்போம் . பூட்டுகள் பற்றி நீங்கள் இங்கே மேலும் படிக்கலாம்: Java 8 StampedLocks vs. ReadWriteLocks மற்றும் Synchronized and Lock API ஜாவாவில். பூட்டுகள் எவ்வாறு செயல்படுத்தப்படுகின்றன என்பதை நன்கு புரிந்து கொள்ள, இந்தக் கட்டுரையில் Phaser பற்றி படிப்பது உதவியாக இருக்கும்: Java Phaser க்கான வழிகாட்டி . பல்வேறு ஒத்திசைவுகளைப் பற்றி பேசுகையில், ஜாவா சின்க்ரோனைசர்ஸ் பற்றிய DZone கட்டுரையை நீங்கள் படிக்க வேண்டும்.

முடிவுரை

இந்த மதிப்பாய்வில், ஜாவாவில் இழைகள் தொடர்பு கொள்ளும் முக்கிய வழிகளை நாங்கள் ஆராய்ந்தோம். கூடுதல் பொருள்:

• ஒன்றாகச் சிறந்தது: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி I - மரணதண்டனையின் நூல்கள்
• https://dzone.com/articles/the-java-synchronizers
• https://www.javatpoint.com/java-multithreading-interview-questions

ஒன்றாகச் சிறந்தது: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி I — செயல்படுத்தும் நூல்கள் ஒன்றாகச் சிறப்பாகச் செயல்படுகின்றன: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி III — ஒன்றாகச் செயல்படுவது சிறந்தது: ஜாவா மற்றும் த்ரெட் வகுப்பு. பகுதி IV - அழைக்கக்கூடிய, எதிர்காலம் மற்றும் நண்பர்கள் ஒன்றாக இருப்பது சிறந்தது: ஜாவா மற்றும் த்ரெட் வகுப்பு. பகுதி V - எக்ஸிகியூட்டர், த்ரெட்பூல், ஃபோர்க்/சேர் பெட்டர் பெட்டர்: ஜாவா மற்றும் த்ரெட் கிளாஸ். பகுதி VI - நெருப்பு!