ஒன்றாகச் சிறந்தது: ஜாவா மற்றும் நூல் வகுப்பு. பகுதி VI - நெருப்பு!

அறிமுகம்

நூல்கள் ஒரு சுவாரஸ்யமான விஷயம். கடந்த மதிப்புரைகளில், மல்டித்ரெடிங்கைச் செயல்படுத்துவதற்கான சில கருவிகளைப் பார்த்தோம். இன்னும் என்னென்ன சுவாரஸ்யமான விஷயங்களைச் செய்யலாம் என்று பார்க்கலாம். இந்த நேரத்தில், எங்களுக்கு நிறைய தெரியும். எடுத்துக்காட்டாக, " Better together: Java and the Thread class. பகுதி I — Threads of execution " என்பதிலிருந்து, Thread class என்பது செயல்படுத்தும் ஒரு நூலைக் குறிக்கிறது என்பதை நாம் அறிவோம். ஒரு நூல் சில பணிகளைச் செய்கிறது என்பதை நாம் அறிவோம். நமது பணிகள் முடிய வேண்டுமானால் run, நாம் நூலைக் குறிக்க வேண்டும் Runnable. நினைவில் கொள்ள, நாம் டுடோரியல்ஸ்பாயிண்ட் ஆன்லைன் ஜாவா கம்பைலரைப் பயன்படுத்தலாம் :

public static void main(String[] args){
	Runnable task = () -> {
 		Thread thread = Thread.currentThread();
		System.out.println("Hello from " + thread.getName());
	};
	Thread thread = new Thread(task);
	thread.start();
}

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

import java.util.concurrent.locks.*;

public class HelloWorld{
	public static void main(String []args){
		Lock lock = new ReentrantLock();
		Runnable task = () -> {
			lock.lock();
			Thread thread = Thread.currentThread();
			System.out.println("Hello from " + thread.getName());
			lock.unlock();
		};
		Thread thread = new Thread(task);
		thread.start();
	}
}

இன்னும் என்னென்ன சுவாரசியமான விஷயங்களைச் செய்ய முடியும் என்பதைப் பற்றி பேச வேண்டிய நேரம் இது என்று நினைக்கிறேன்.

செமாஃபோர்ஸ்

ஒரே நேரத்தில் எத்தனை நூல்கள் இயங்க முடியும் என்பதைக் கட்டுப்படுத்துவதற்கான எளிய வழி செமாஃபோர் ஆகும். இது ரயில்வே சிக்னல் போன்றது. பச்சை என்றால் தொடருங்கள். சிவப்பு என்றால் காத்திரு. செமாஃபோரிலிருந்து எதற்காக காத்திருங்கள்? அணுகல். அணுகலைப் பெற, நாம் அதைப் பெற வேண்டும். அணுகல் தேவையில்லாத போது, ​​நாம் அதை கொடுக்க வேண்டும் அல்லது விடுவிக்க வேண்டும். இது எப்படி வேலை செய்கிறது என்று பார்க்கலாம். நாம் வகுப்பை இறக்குமதி செய்ய வேண்டும் java.util.concurrent.Semaphore. உதாரணமாக:

public static void main(String[] args) throws InterruptedException {
	Semaphore semaphore = new Semaphore(0);
	Runnable task = () -> {
		try {
			semaphore.acquire();
			System.out.println("Finished");
			semaphore.release();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	};
	new Thread(task).start();
	Thread.sleep(5000);
	semaphore.release(1);
}

நீங்கள் பார்க்க முடியும் என, இந்த செயல்பாடுகள் (பெறுதல் மற்றும் வெளியிடுதல்) செமாஃபோர் எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்ள உதவுகிறது. மிக முக்கியமான விஷயம் என்னவென்றால், நாம் அணுகலைப் பெற வேண்டுமானால், செமாஃபோருக்கு நேர்மறை எண்ணிக்கையிலான அனுமதிகள் இருக்க வேண்டும். இந்த எண்ணிக்கையை எதிர்மறை எண்ணுக்கு துவக்கலாம். மேலும் 1 அனுமதிக்கு மேல் நாம் கோரலாம் (பெறலாம்).

கவுண்ட்டவுன்லாட்ச்

அடுத்த பொறிமுறை CountDownLatch. ஆச்சரியப்படத்தக்க வகையில், இது கவுண்டவுன் கொண்ட தாழ்ப்பாள். இங்கே வகுப்பிற்கான பொருத்தமான இறக்குமதி அறிக்கை தேவை java.util.concurrent.CountDownLatch. இது ஒரு கால் பந்தயம் போன்றது, அங்கு எல்லோரும் தொடக்க வரிசையில் கூடுகிறார்கள். எல்லோரும் தயாரானதும், அனைவரும் ஒரே நேரத்தில் தொடக்க சமிக்ஞையைப் பெற்று ஒரே நேரத்தில் தொடங்குகிறார்கள். உதாரணமாக:

public static void main(String[] args) {
	CountDownLatch countDownLatch = new CountDownLatch(3);
	Runnable task = () -> {
		try {
			countDownLatch.countDown();
			System.out.println("Countdown: " + countDownLatch.getCount());
			countDownLatch.await();
			System.out.println("Finished");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	};
	for (int i = 0; i < 3; i++) {
		new Thread(task).start();
 	}
}

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

சுழற்சி தடுப்பு

பெயர் குறிப்பிடுவது போல, CyclicBarrierஇது "மீண்டும் பயன்படுத்தக்கூடிய" தடையாகும். நாங்கள் வகுப்பை இறக்குமதி செய்ய வேண்டும் java.util.concurrent.CyclicBarrier. ஒரு உதாரணத்தைப் பார்ப்போம்:

public static void main(String[] args) throws InterruptedException {
	Runnable action = () -> System.out.println("On your mark!");
	CyclicBarrier barrier = new CyclicBarrier(3, action);
	Runnable task = () -> {
		try {
			barrier.await();
			System.out.println("Finished");
		} catch (BrokenBarrierException | InterruptedException e) {
			e.printStackTrace();
		}
	};
	System.out.println("Limit: " + barrier.getParties());
	for (int i = 0; i < 3; i++) {
		new Thread(task).start();
	}
}

நீங்கள் பார்க்க முடியும் என, நூல் awaitமுறையை இயக்குகிறது, அதாவது அது காத்திருக்கிறது. இந்த வழக்கில், தடை மதிப்பு குறைகிறது. barrier.isBroken()கவுண்டவுன் பூஜ்ஜியத்தை அடையும் போது தடை உடைந்ததாகக் கருதப்படுகிறது ( ). தடையை மீட்டமைக்க, நீங்கள் இல்லாத reset()முறையை அழைக்க வேண்டும்.CountDownLatch

பரிமாற்றி

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

public static void main(String[] args) {
	Exchanger<String> exchanger = new Exchanger<>();
	Runnable task = () -> {
		try {
			Thread thread = Thread.currentThread();
			String withThreadName = exchanger.exchange(thread.getName());
			System.out.println(thread.getName() + " exchanged with " + withThreadName);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	};
	new Thread(task).start();
	new Thread(task).start();
}

இங்கே நாம் இரண்டு நூல்களைத் தொடங்குகிறோம். அவை ஒவ்வொன்றும் பரிமாற்ற முறையை இயக்குகிறது மற்றும் பரிமாற்ற முறையை இயக்க மற்ற திரி காத்திருக்கிறது. அவ்வாறு செய்யும்போது, ​​இழைகள் நிறைவேற்றப்பட்ட வாதங்களை பரிமாறிக் கொள்கின்றன. சுவாரஸ்யமானது. இது உங்களுக்கு ஏதாவது நினைவூட்டுகிறது அல்லவா? இது நினைவூட்டுகிறது SynchronousQueue, இது இதயத்தில் உள்ளது CachedThreadPool. தெளிவுக்காக, இங்கே ஒரு எடுத்துக்காட்டு:

public static void main(String[] args) throws InterruptedException {
	SynchronousQueue<String> queue = new SynchronousQueue<>();
	Runnable task = () -> {
		try {
			System.out.println(queue.take());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	};
	new Thread(task).start();
	queue.put("Message");
}

ஒரு புதிய திரி தொடங்கப்படும் போது, ​​அது காத்திருக்கும், ஏனெனில் வரிசை காலியாக இருக்கும் என்பதை எடுத்துக்காட்டு காட்டுகிறது. பின்னர் முக்கிய நூல் "செய்தி" சரத்தை வரிசையில் வைக்கிறது. மேலும், வரிசையில் இருந்து இந்த சரம் பெறும் வரை அதுவும் நின்றுவிடும். இந்தத் தலைப்பைப் பற்றி மேலும் அறிய, " SynchronousQueue vs Exchanger " என்பதையும் நீங்கள் படிக்கலாம் .

பேசர்

கடைசியாக சிறந்ததைச் சேமித்துள்ளோம் — Phaser. நாங்கள் வகுப்பை இறக்குமதி செய்ய வேண்டும் java.util.concurrent.Phaser. ஒரு எளிய உதாரணத்தைப் பார்ப்போம்:

public static void main(String[] args) throws InterruptedException {
        Phaser phaser = new Phaser();
        // By calling the register method, we register the current (main) thread as a party
        phaser.register();
        System.out.println("Phasecount is " + phaser.getPhase());
        testPhaser(phaser);
        testPhaser(phaser);
        testPhaser(phaser);
        // After 3 seconds, we arrive at the barrier and deregister. Number of arrivals = number of registrations = start
        Thread.sleep(3000);
        phaser.arriveAndDeregister();
        System.out.println("Phasecount is " + phaser.getPhase());
    }

    private static void testPhaser(final Phaser phaser) {
        // We indicate that there will be a +1 party on the Phaser
        phaser.register();
        // Start a new thread
        new Thread(() -> {
            String name = Thread.currentThread().getName();
            System.out.println(name + " arrived");
            phaser.arriveAndAwaitAdvance(); // The threads register arrival at the phaser.
            System.out.println(name + " after passing barrier");
        }).start();
    }

Phaserபயன்படுத்தும் போது , ​​பதிவுகளின் எண்ணிக்கை தடையில் வந்தவர்களின் எண்ணிக்கையுடன் பொருந்தும்போது தடை உடைகிறது என்பதை எடுத்துக்காட்டு விளக்குகிறது . இந்த GeeksforGeeks கட்டுரையைப்Phaser படிப்பதன் மூலம் நீங்கள் இன்னும் நன்கு தெரிந்துகொள்ளலாம் .

சுருக்கம்

இந்த எடுத்துக்காட்டுகளிலிருந்து நீங்கள் பார்க்க முடியும் என, நூல்களை ஒத்திசைக்க பல்வேறு வழிகள் உள்ளன. முன்னதாக, மல்டித்ரெடிங்கின் அம்சங்களை நினைவுபடுத்த முயற்சித்தேன். இந்தத் தொடரின் முந்தைய பகுதிகள் பயனுள்ளதாக இருக்கும் என்று நம்புகிறேன். மல்டித்ரெடிங்கிற்கான பாதை "ஜாவா கன்கரன்சி இன் பிராக்டீஸ்" புத்தகத்தில் இருந்து தொடங்குகிறது என்று சிலர் கூறுகிறார்கள். இது 2006 இல் வெளியிடப்பட்டாலும், இந்த புத்தகம் மிகவும் அடித்தளமாகவும் இன்றும் பொருத்தமானதாகவும் இருப்பதாக மக்கள் கூறுகிறார்கள். எடுத்துக்காட்டாக, நீங்கள் விவாதத்தை இங்கே படிக்கலாம்: "ஜாவா கன்கரன்சி நடைமுறையில்" இன்னும் செல்லுபடியாகுமா? . விவாதத்தில் உள்ள இணைப்புகளைப் படிப்பதும் பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, தி வெல்-கிரவுண்டட் ஜாவா டெவலப்பர் என்ற புத்தகத்திற்கு ஒரு இணைப்பு உள்ளது , மேலும் அத்தியாயம் 4. நவீன ஒத்திசைவு பற்றி குறிப்பாக குறிப்பிடுவோம் . இந்த தலைப்பைப் பற்றிய முழு மதிப்பாய்வும் உள்ளது:ஜாவா 8 இன் சகாப்தத்தில் "நடைமுறையில் ஜாவா ஒத்திசைவு" இன்னும் செல்லுபடியாகுமா? இந்தத் தலைப்பை உண்மையாகப் புரிந்துகொள்ள வேறு என்ன படிக்க வேண்டும் என்பது பற்றிய பரிந்துரைகளையும் அந்தக் கட்டுரை வழங்குகிறது. அதன் பிறகு, OCA/OCP ஜாவா SE 8 புரோகிராமர் பயிற்சி சோதனைகள் போன்ற சிறந்த புத்தகத்தைப் பார்க்கலாம் . இரண்டாவது சுருக்கத்தில் நாங்கள் ஆர்வமாக உள்ளோம்: OCP (Oracle Certified Professional). "அத்தியாயம் 20: ஜாவா கன்கரன்சி"யில் சோதனைகளைக் காணலாம். இந்த புத்தகத்தில் கேள்விகள் மற்றும் பதில்கள் இரண்டும் விளக்கங்கள் உள்ளன. எடுத்துக்காட்டாக: இந்த கேள்வி முறைகளை மனப்பாடம் செய்வதற்கான மற்றொரு எடுத்துக்காட்டு என்று பலர் சொல்ல ஆரம்பிக்கலாம். ஒருபுறம், ஆம். மறுபுறம், ExecutorServiceஒரு வகையான "மேம்படுத்துதல்" என்பதை நினைவுபடுத்துவதன் மூலம் இந்தக் கேள்விக்கு நீங்கள் பதிலளிக்கலாம் Executor. மற்றும்Executorநூல்கள் உருவாக்கப்படும் வழியை வெறுமனே மறைக்கும் நோக்கம் கொண்டது, ஆனால் அவற்றை இயக்குவதற்கான முக்கிய வழி அல்ல, அதாவது Runnableஒரு புதிய நூலில் ஒரு பொருளைத் தொடங்கவும். அதனால்தான் இல்லை execute(Callable)— ஏனெனில் ExecutorService, ஒரு பொருளைத் திரும்பப் பெறக்கூடிய முறைகளைச் Executorசேர்க்கிறது . நிச்சயமாக, நாம் முறைகளின் பட்டியலை மனப்பாடம் செய்யலாம், ஆனால் வகுப்புகளின் தன்மையைப் பற்றிய நமது அறிவின் அடிப்படையில் எங்கள் பதிலை உருவாக்குவது மிகவும் எளிதானது. தலைப்பில் சில கூடுதல் பொருட்கள் இங்கே: submit()Future

• java.util.concurrent தொகுப்பு
• ஜாவா சின்க்ரோனைசர்ஸ்
• டக்ளஸ் ஹாக்கின்ஸ் எழுதிய ஜாவாவில் கன்கரன்சி கான்செப்ட்ஸ்

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