కలిసి ఉత్తమం: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ VI — ఫైర్ అవే!

పరిచయం

థ్రెడ్లు ఒక ఆసక్తికరమైన విషయం. గత సమీక్షలలో, మేము మల్టీథ్రెడింగ్‌ని అమలు చేయడానికి అందుబాటులో ఉన్న కొన్ని సాధనాలను పరిశీలించాము. మనం ఇంకా ఎలాంటి ఆసక్తికరమైన విషయాలు చేయగలమో చూద్దాం. ఈ సమయంలో, మనకు చాలా తెలుసు. ఉదాహరణకు, " బెటర్ టుగెదర్: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ I — థ్రెడ్స్ ఆఫ్ ఎగ్జిక్యూషన్ " నుండి, థ్రెడ్ క్లాస్ ఎగ్జిక్యూషన్ థ్రెడ్‌ని సూచిస్తుందని మాకు తెలుసు. థ్రెడ్ కొంత పనిని చేస్తుందని మాకు తెలుసు. మన పనులు చేయగలిగితే 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(). Google కౌంట్‌డౌన్‌ను "సున్నాకి రివర్స్ ఆర్డర్‌లో సంఖ్యలను లెక్కించే చర్య"గా నిర్వచిస్తుంది. ఆపై మేము గొళ్ళెం కు చెప్తాము await(), అంటే కౌంటర్ సున్నా అయ్యే వరకు వేచి ఉండండి. ఆసక్తికరంగా, ఇది వన్-టైమ్ కౌంటర్. జావా డాక్యుమెంటేషన్ ఇలా చెబుతోంది, "థ్రెడ్‌లు ఈ విధంగా పదేపదే లెక్కించవలసి వచ్చినప్పుడు, బదులుగా సైక్లిక్‌బారియర్‌ని ఉపయోగించండి". మరో మాటలో చెప్పాలంటే, మీకు పునర్వినియోగ కౌంటర్ అవసరమైతే, మీకు వేరే ఎంపిక అవసరం: 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 Java SE 8 ప్రోగ్రామర్ ప్రాక్టీస్ టెస్ట్‌ల వంటి గొప్ప పుస్తకాన్ని చూడవచ్చు . మేము రెండవ సంక్షిప్త పదంపై ఆసక్తి కలిగి ఉన్నాము: OCP (ఒరాకిల్ సర్టిఫైడ్ ప్రొఫెషనల్). మీరు "చాప్టర్ 20: జావా కరెన్సీ"లో పరీక్షలను కనుగొంటారు. ఈ పుస్తకంలో వివరణలతో కూడిన ప్రశ్నలు మరియు సమాధానాలు రెండూ ఉన్నాయి. ఉదాహరణకు: చాలా మంది వ్యక్తులు ఈ ప్రశ్న పద్ధతులను గుర్తుంచుకోవడానికి మరొక ఉదాహరణ అని చెప్పడం ప్రారంభించవచ్చు. ఒక వైపు, అవును. మరోవైపు, ExecutorServiceఒక రకమైన "అప్‌గ్రేడ్" అని గుర్తుచేసుకోవడం ద్వారా మీరు ఈ ప్రశ్నకు సమాధానం ఇవ్వవచ్చు Executor. మరియుExecutorథ్రెడ్‌లను సృష్టించే విధానాన్ని దాచడానికి ఉద్దేశించబడింది, కానీ వాటిని అమలు చేయడానికి ఇది ప్రధాన మార్గం కాదు, అంటే Runnableకొత్త థ్రెడ్‌లో ఒక వస్తువును ప్రారంభించండి. అందుకే ఏదీ లేదు execute(Callable)— ఎందుకంటే లో ExecutorService, Executor​​కేవలం submit()ఒక వస్తువును తిరిగి ఇవ్వగల పద్ధతులను జోడిస్తుంది Future. వాస్తవానికి, మేము పద్ధతుల జాబితాను గుర్తుంచుకోగలము, అయితే తరగతుల స్వభావం గురించి మనకున్న జ్ఞానం ఆధారంగా మా సమాధానాన్ని తయారు చేయడం చాలా సులభం. మరియు అంశంపై ఇక్కడ కొన్ని అదనపు పదార్థాలు ఉన్నాయి:

• java.util.concurrent ప్యాకేజీ
• జావా సింక్రొనైజర్స్
• డగ్లస్ హాకిన్స్చే జావాలో కాన్కరెన్సీ కాన్సెప్ట్స్

కలిసి ఉత్తమం: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ I — థ్రెడ్స్ ఆఫ్ ఎగ్జిక్యూషన్ కలిసి మెరుగ్గా ఉంటుంది: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ II — సమకాలీకరణ ఉత్తమం: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ III — కలిసి మెరుగ్గా పరస్పర చర్య: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ IV — కాల్ చేయదగినది, భవిష్యత్తు మరియు స్నేహితులు కలిసి ఉండటం మంచిది: జావా మరియు థ్రెడ్ క్లాస్. పార్ట్ V - ఎగ్జిక్యూటర్, థ్రెడ్‌పూల్, ఫోర్క్/జాయిన్