گڏو گڏ بهتر: جاوا ۽ ٿريڊ ڪلاس. حصو VI - فائر پري!

تعارف

موضوع هڪ دلچسپ شيء آهي. ماضي جي نظرثانين ۾، اسان ڏٺو ته ڪجھ دستياب اوزار ملٽي ٿريڊنگ کي لاڳو ڪرڻ لاءِ. اچو ته ڏسو ته ٻيون دلچسپ شيون جيڪي اسان ڪري سگهون ٿا. هن موقعي تي، اسان تمام گهڻو ڄاڻون ٿا. مثال طور، " Better together: Java and the Thread class. Part I - Threads of execution " مان، اسان ڄاڻون ٿا ته Thread class execution جي سلسلي جي نمائندگي ڪري ٿو. اسان ڄاڻون ٿا ته هڪ موضوع ڪجهه ڪم انجام ڏئي ٿو. جيڪڏهن اسان چاهيون ٿا ته اسان جا ڪم ڪرڻ جي قابل ٿي وڃن run، ته پوءِ اسان کي ان سلسلي کي نشان لڳائڻ گهرجي Runnable. ياد رکڻ لاءِ، اسان استعمال ڪري سگھون ٿا Tutorialspoint Online Java Compiler :

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();
}

اسان اهو پڻ ڄاڻون ٿا ته اسان وٽ ڪجهه آهي جنهن کي تالا سڏيو ويندو آهي. اسان ان جي باري ۾ " Better together: Java and the Thread class. Part II - Synchronization . جيڪڏهن هڪ ٿريڊ هڪ لاڪ حاصل ڪري ٿي، ته پوءِ ٻيو ٿريڊ جيڪو لاڪ حاصل ڪرڻ جي ڪوشش ڪري ٿو، ان لاڪ جي جاري ٿيڻ جو انتظار ڪرڻ تي مجبور ڪيو ويندو:

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

ايندڙ ميڪانيزم آهي 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. ان سلسلي ۾، هڪ مٽا سٽا هڪ هم وقت سازي نقطو آهي جتي شيون تبديل ٿي وينديون آهن يا تبديل ٿي وينديون آهن. جيئن توهان توقع ڪندا، هڪ 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، رڪاوٽ ٽوڙي ٿو جڏهن رجسٽريشن جو تعداد رڪاوٽ تي اچڻ وارن جي تعداد سان ملندو آهي. Phaserتوهان هن پڙهڻ سان وڌيڪ واقف ٿي سگهو ٿا GeeksforGeeks مضمون .

خلاصو

جئين توهان انهن مثالن مان ڏسي سگهو ٿا، موضوعن کي هم وقت سازي ڪرڻ جا مختلف طريقا آهن. ان کان اڳ، مون multithreading جي حصن کي ياد ڪرڻ جي ڪوشش ڪئي. مون کي اميد آهي ته هن سلسلي ۾ پوئين قسطون ڪارائتيون هيون. ڪجهه ماڻهو چون ٿا ته ملٽي ٿريڊنگ جو رستو ڪتاب سان شروع ٿئي ٿو "جاوا اتفاق سان مشق ۾". جيتوڻيڪ اهو 2006 ۾ جاري ڪيو ويو، ماڻهن جو چوڻ آهي ته ڪتاب ڪافي بنيادي ۽ اڄ به لاڳاپيل آهي. مثال طور، توهان هتي بحث پڙهي سگهو ٿا: ڇا "جاوا اتفاق سان عمل ۾" اڃا به صحيح آهي؟ . بحث ۾ لنڪس پڙهڻ لاء پڻ مفيد آهي. مثال طور، ڪتاب The Well-Grounded Java Developer جي لنڪ آهي ، ۽ اسان باب 4 جو خاص ذڪر ڪنداسين. Modern concurrency . هن موضوع بابت هڪ مڪمل جائزو پڻ آهي: ڇا "جاوا اتفاق سان عمل ۾" اڃا تائين صحيح آهي جاوا 8 جي دور ۾؟ اهو آرٽيڪل پڻ تجويز پيش ڪري ٿو ته هن موضوع کي سمجهڻ لاءِ ٻيو ڇا پڙهو. ان کان پوء، توهان هڪ بهترين ڪتاب ڏسي سگهو ٿا جهڙوڪ OCA/OCP Java SE 8 پروگرامر مشق ٽيسٽ . اسان ٻئي مخفف ۾ دلچسپي رکون ٿا: OCP (Oracle Certified Professional). توھان کي "باب 20: جاوا اتفاق" ۾ ٽيسٽ ملندا. هن ڪتاب ۾ وضاحت سان گڏ سوال ۽ جواب ٻئي آهن. مثال طور: گھڻا ماڻھو چوڻ شروع ڪري سگھن ٿا ته ھي سوال اڃا تائين طريقن جي يادگيري جو ھڪڙو ٻيو مثال آھي. هڪ پاسي، ها. ٻئي طرف، توهان هن سوال جو جواب ڏئي سگهو ٿا ياد ڪندي اهو ExecutorServiceهڪ قسم جو "اپ گريڊ" آهي Executor. ۽ Executorمقصد صرف لڪائڻ جو طريقو آهي ته جيئن موضوع ٺاهيا ويا آهن، پر اهو انهن تي عمل ڪرڻ جو بنيادي طريقو ناهي، اهو آهي، Runnableنئين موضوع تي اعتراض شروع ڪريو. اهو ئي سبب آهي ته ڪو به ناهي execute(Callable)- ڇاڪاڻ ته ۾ ExecutorService، Executorصرف submit()طريقن کي شامل ڪري ٿو جيڪو هڪ Futureاعتراض کي واپس ڪري سگهي ٿو. يقينن، اسان طريقن جي هڪ فهرست کي ياد ڪري سگهون ٿا، پر اهو اسان جي جوابن کي اسان جي ڄاڻ جي بنياد تي بڻائڻ آسان آهي ته طبقن جي فطرت بابت. ۽ هتي موضوع تي ڪجهه اضافي مواد آهن:

• java.util.concurrent پيڪيج
• جاوا هم وقت ساز
• Douglas Hawkins پاران جاوا ۾ اتفاق راءِ

گڏو گڏ بهتر: جاوا ۽ ٿريڊ ڪلاس. حصو I - عملدرآمد جا موضوع گڏ ڪري بهتر: جاوا ۽ ٿريڊ ڪلاس. حصو II - هم وقت سازي بهتر گڏجي: جاوا ۽ ٿريڊ ڪلاس. حصو III - رابطي بهتر گڏجي: جاوا ۽ ٿريڊ ڪلاس. حصو IV — سڏڻ لائق، مستقبل، ۽ دوست گڏ ڪري بهتر: جاوا ۽ ٿريڊ ڪلاس. حصو V - ايگزيڪيوٽر، ٿريڊ پول، فورڪ/شامل