مٿيان 50 جاوا ڪور انٽرويو سوال ۽ جواب. حصو 3

مٿيان 50 جاوا ڪور انٽرويو سوال ۽ جواب. حصو 1 مٿي 50 جاوا ڪور انٽرويو سوال ۽ جواب. حصو 2

ملٽي ٽريڊنگ

37. جاوا ۾ نئون ٿريڊ (flow) ڪيئن ٺاھيو؟

هڪ طريقو يا ٻيو، تخليق ٿريڊ ڪلاس جي استعمال ذريعي ٿئي ٿي. پر هتي جا اختيار ٿي سگهن ٿا ...

1. مان ورثي ۾ مليا آهيونjava.lang.Thread
2. اسان هڪ انٽرفيس تي عمل ڪندا آهيون java.lang.Runnableجنهن جو اعتراض هڪ تعمير ڪندڙ Threadطبقي کي قبول ڪري ٿو

اچو ته انهن مان هر هڪ بابت ڳالهايون.

اسان ٿريڊ ڪلاس مان ورثي ۾ آهيون

هي ڪم ڪرڻ لاءِ، اسان جي ڪلاس ۾ اسان کي ورثي ۾ ملي ٿو java.lang.Thread. اهو ميٿ تي مشتمل آهي run()، جيڪو اسان کي گهربل آهي. نئين سلسلي جي سموري زندگي ۽ منطق هن طريقي ۾ ٿيندي. هي هڪ قسم جو mainطريقو آهي نئين سلسلي لاءِ. ان کان پوء، باقي رهي ٿو ته اسان جي ڪلاس جو هڪ اعتراض ٺاهيو ۽ طريقي سان عمل ڪيو وڃي start()، جيڪو هڪ نئون موضوع ٺاهيندو ۽ ان ۾ لکيل منطق کي هلائيندو. اچو ته ڏسون:

/**
* Пример того, How создавать треды путем наследования {@link Thread} класса.
*/
class ThreadInheritance extends Thread {

   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
   }

   public static void main(String[] args) {
       ThreadInheritance threadInheritance1 = new ThreadInheritance();
       ThreadInheritance threadInheritance2 = new ThreadInheritance();
       ThreadInheritance threadInheritance3 = new ThreadInheritance();
       threadInheritance1.start();
       threadInheritance2.start();
       threadInheritance3.start();
   }
}

ڪنسول جي پيداوار هن طرح ٿيندي:

Thread-1
Thread-0
Thread-2

اهو آهي، هتي به اسان ڏسون ٿا ته موضوعن تي عمل نه ڪيو ويو آهي، پر جيئن ته JVM فيصلو ڪيو)

هلائڻ واري انٽرفيس کي لاڳو ڪرڻ

جيڪڏهن توهان وراثت جي خلاف آهيو ۽/يا اڳ ۾ ئي هڪ ٻئي طبقن جا وارث آهيو، توهان استعمال ڪري سگهو ٿا java.lang.Runnable. هتي اسان جي ڪلاس ۾ اسان هن انٽرفيس کي لاڳو ڪريون ٿا ۽ طريقي کي لاڳو ڪريون ٿا run()، جيئن هن مثال ۾ هو. توهان کي صرف وڌيڪ شيون ٺاهڻ جي ضرورت آهي Thread. اهو لڳي ٿو ته وڌيڪ لائينون خراب آهن. پر اسان ڄاڻون ٿا ته وراثت ڪيتري نقصانڪار آهي ۽ اهو بهتر آهي ته ان کان هر طرح کان پاسو ڪجي؛) اچو ته ڏسون:

/**
* Пример того, How создавать треды из интерфейса {@link Runnable}.
* Здесь проще простого - реализуем этот интерфейс и потом передаем в конструктор
* экземпляр реализуемого an object.
*/
class ThreadInheritance implements Runnable {

   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
   }

   public static void main(String[] args) {
       ThreadInheritance runnable1 = new ThreadInheritance();
       ThreadInheritance runnable2 = new ThreadInheritance();
       ThreadInheritance runnable3 = new ThreadInheritance();

       Thread threadRunnable1 = new Thread(runnable1);
       Thread threadRunnable2 = new Thread(runnable2);
       Thread threadRunnable3 = new Thread(runnable3);

       threadRunnable1.start();
       threadRunnable2.start();
       threadRunnable3.start();
   }
}

۽ عمل جو نتيجو:

Thread-0
Thread-1
Thread-2

38. هڪ عمل ۽ سلسلي جي وچ ۾ ڇا فرق آهي؟

ھڪڙي عمل ۽ ھڪڙي سلسلي جي وچ ۾ ھيٺيون فرق آھن:

1. عمل ۾ هڪ پروگرام کي پروسيس سڏيو ويندو آهي، جڏهن ته هڪ سلسلي هڪ عمل جو هڪ ذيلي سيٽ آهي.
2. پروسيس آزاد آهن، جڏهن ته موضوع هڪ عمل جو هڪ ذيلي سيٽ آهن.
3. پروسيس ۾ ميموري ۾ مختلف ايڊريس اسپيس هونديون آهن، جڏهن ته ٿريڊ ۾ هڪ عام ايڊريس اسپيس هوندي آهي.
4. حوالن جي مٽائڻ واري عمل جي مقابلي ۾ سلسلي جي وچ ۾ تيز آهي.
5. انٽرپروسيس ڪميونيڪيشن انٽر ٿريڊ ڪميونيڪيشن کان سست ۽ وڌيڪ مهانگو آهي.
6. والدين جي عمل ۾ ڪا به تبديلي ٻار جي عمل کي متاثر نه ڪندي، جڏهن ته والدين سلسلي ۾ تبديليون ٻار جي سلسلي کي متاثر ڪري سگهن ٿيون.

39. ملٽي ٿريڊنگ جا ڪهڙا فائدا آهن؟

1. ملٽي ٿريڊنگ هڪ ايپليڪيشن/پروگرام کي هميشه ان پٽ تي جواب ڏيڻ جي اجازت ڏئي ٿي جيتوڻيڪ اهو اڳ ۾ ئي ڪجهه پس منظر جا ڪم هلائي رهيو آهي.
2. ملٽي ٿريڊنگ توهان کي ڪم تيزيءَ سان مڪمل ڪرڻ جي اجازت ڏئي ٿي ڇو ته ٿريڊز آزاديءَ سان عمل ڪن ٿا؛
3. ملٽي ٿريڊنگ بهتر ڪيش استعمال فراهم ڪري ٿي ڇو ته ٿريڊ عام ياداشت جا وسيلا شيئر ڪن ٿا؛
4. ملٽي ٿريڊنگ سرور جي گهربل مقدار کي گھٽائي ٿي ڇاڪاڻ ته هڪ سرور هڪ ئي وقت ڪيترن ئي موضوعن کي هلائي سگهي ٿو.

40. هڪ سلسلي جي زندگيءَ جي چڪر ۾ ڪهڙيون رياستون آهن؟

1. نئون: هن حالت ۾، Threadنئين آپريٽر استعمال ڪندي هڪ طبقاتي اعتراض ٺاهيو ويندو آهي، پر موضوع موجود ناهي. سلسلو شروع نه ٿيندو جيستائين اسان ڪال نه ڪندا آهيون start().
2. رننبل: هن حالت ۾، ڌاڳو طريقو سڏڻ کان پوء هلائڻ لاء تيار آهي شروع (). بهرحال، اهو اڃا تائين موضوع جي شيڊولر طرفان نه چونڊيو ويو آهي.
3. رننگ: هن حالت ۾، ٿريڊ شيڊولر تيار ٿيل رياست مان هڪ موضوع چونڊيندو آهي ۽ اهو هلندو آهي.
4. انتظار/ بند ٿيل: ھن حالت ۾، موضوع ھلندڙ نه آھي پر اڃا تائين جيئرو آھي يا ٻئي سلسلي جي مڪمل ٿيڻ جي انتظار ۾.
5. مئل / ختم ٿيل: جڏهن طريقو نڪرندو آهي، run()موضوع ختم ٿيل يا مئل حالت ۾ آهي.

41. ڇا ان سلسلي کي ٻه ڀيرا شروع ڪرڻ ممڪن آهي؟

نه، اسان ٿريڊ کي ٻيهر شروع نٿا ڪري سگھون ڇاڪاڻ ته هڪ ڀيرو ٿريڊ شروع ٿي ۽ عمل ڪيو وڃي ٿو، اهو مئل حالت ۾ وڃي ٿو. تنهن ڪري جيڪڏهن اسان ٿريڊ کي ٻه ڀيرا هلائڻ جي ڪوشش ڪنداسين ته اهو هڪ runtimeException " java.lang.IllegalThreadStateException " اڇلائي ڇڏيندو. اچو ته ڏسون:

class DoubleStartThreadExample extends Thread {

   /**
    * Имитируем работу треда
    */
   public void run() {
	// что-то происходит. Для нас не существенно на этом этапе
   }

   /**
    * Запускаем тред дважды
    */
   public static void main(String[] args) {
       DoubleStartThreadExample doubleStartThreadExample = new DoubleStartThreadExample();
       doubleStartThreadExample.start();
       doubleStartThreadExample.start();
   }
}

جيترو جلدي ڪم ساڳئي سلسلي جي ٻئي شروعات تي پهچندو، پوء اتي هڪ استثنا هوندو. پاڻ ڪوشش ڪريو؛) اھو بھتر آھي ته ھڪ ڀيرو ڏسڻ کان سؤ ڀيرا ٻڌڻ کان.

42. جيڪڏهن توهان start() ميٿڊ کي ڪال ڪرڻ کان سواءِ سڌو رن() ميٿڊ کي ڪال ڪريو ٿا؟

ها، run()يقيناً توهان هڪ طريقو ڪال ڪري سگهو ٿا، پر اهو هڪ نئون ٿريڊ نه ٺاهيندو ۽ ان کي الڳ ٿريڊ طور تي عمل ڪندو. انهي حالت ۾، اهو هڪ سادي اعتراض آهي جيڪو هڪ سادي طريقو سڏيندو آهي. جيڪڏهن اسان طريقي جي باري ۾ ڳالهايون ٿا start()، ته اها ٻي ڳالهه آهي. هن طريقي کي شروع ڪرڻ سان، runtimeاهو هڪ نئون شروع ڪري ٿو ۽ اهو، موڙ ۾، اسان جو طريقو هلندو آهي؛) جيڪڏهن توهان مون تي يقين نه ٿا ڪريو، ڪوشش ڪريو:

class ThreadCallRunExample extends Thread {

   public void run() {
       for (int i = 0; i < 5; i++) {
           System.out.print(i);
       }
   }

   public static void main(String args[]) {
       ThreadCallRunExample runExample1 = new ThreadCallRunExample();
       ThreadCallRunExample runExample2 = new ThreadCallRunExample();

       // просто будут вызваны в потоке main два метода, один за другим.
       runExample1.run();
       runExample2.run();
   }
}

۽ ڪنسول ڏانهن آئوٽ هن طرح ٿيندو:

0123401234

اهو ڏسي سگهجي ٿو ته ڪو به سلسلو پيدا نه ڪيو ويو آهي. سڀ ڪجهه عام طبقي وانگر ڪم ڪيو. پهرين فرسٽ ڪلاس جو طريقو ڪم ڪيو، پوءِ ٻيو.

43. ڊيمون ٿريڊ ڇا آهي؟

ڊيمون ٿريڊ (جنهن کي بعد ۾ ڊيمون ٿريڊ چيو ويندو آهي) هڪ ٿريڊ آهي جيڪو پس منظر ۾ ڪم سرانجام ڏئي ٿو ڪنهن ٻئي سلسلي جي حوالي سان. اهو آهي، ان جو ڪم معاون ڪمن کي انجام ڏيڻ آهي جيڪو صرف ٻئي (مکيه) سلسلي سان گڏ ڪرڻ جي ضرورت آهي. اهڙا ڪيترائي ڊيمون موضوع آهن جيڪي خودڪار طريقي سان ڪم ڪن ٿا، جهڙوڪ گاربيج ڪليڪٽر، فائنلائزر وغيره.

جاوا ڊيمون ٿريڊ کي ڇو بند ڪري ٿو؟

ڊيمون سلسلي جو واحد مقصد اهو آهي ته اهو صارف جي سلسلي کي پس منظر سپورٽ ڪم لاءِ خدمتون مهيا ڪري ٿو. تنهن ڪري، جيڪڏهن مکيه موضوع مڪمل ٿي چڪو آهي، پوء رن ٽائم خودڪار طريقي سان ان جي سڀني ڊيمن جي سلسلي کي بند ڪري ٿو.

ٿريڊ ڪلاس ۾ ڪم ڪرڻ جا طريقا

ڪلاس java.lang.Threadٿريڊ ڊيمن سان ڪم ڪرڻ جا ٻه طريقا مهيا ڪري ٿو:

1. public void setDaemon(boolean status)- ظاھر ڪري ٿو ته ھي ھڪڙو ڊيمون موضوع ھوندو. ڊفالٽ آهي false، جنهن جو مطلب آهي ته غير ڊيمون موضوع ٺاهيا ويندا جيستائين الڳ الڳ بيان نه ڪيو وڃي.
2. public boolean isDaemon()- بنيادي طور تي اھو ھڪڙو حاصل ڪندڙ آھي متغير لاءِ daemonجيڪو اسان اڳئين طريقي سان سيٽ ڪيو آھي.

مثال:

class DaemonThreadExample extends Thread {

   public void run() {
       // Проверяет, демон ли этот поток or нет
       if (Thread.currentThread().isDaemon()) {
           System.out.println("daemon thread");
       } else {
           System.out.println("user thread");
       }
   }

   public static void main(String[] args) {
       DaemonThreadExample thread1 = new DaemonThreadExample();
       DaemonThreadExample thread2 = new DaemonThreadExample();
       DaemonThreadExample thread3 = new DaemonThreadExample();

       // теперь thread1 - поток-демон.
       thread1.setDaemon(true);

       System.out.println("демон?.. " + thread1.isDaemon());
       System.out.println("демон?.. " + thread2.isDaemon());
       System.out.println("демон?.. " + thread3.isDaemon());

       thread1.start();
       thread2.start();
       thread3.start();
   }
}

ڪنسول آئوٽ:

демон?.. true
демон?.. false
демон?.. false
daemon thread
user thread
user thread

آئوٽ پُٽ مان اسان ڏسون ٿا ته ٿريڊ جي اندر ئي هڪ جامد currentThread()طريقو استعمال ڪندي اهو معلوم ڪري سگهون ٿا ته هڪ طرف اها ڪهڙي ٿريڊ آهي ته ٻئي طرف جيڪڏهن اسان کي هن ٿريڊ جي اعتراض جو ڪو حوالو هجي ته معلوم ڪري سگهون ٿا. ان کان سڌو. هي ترتيب ۾ ضروري لچڪ ڏئي ٿو.

44. ڇا اهو ممڪن آهي ته ڌاڳو ٺهڻ کان پوءِ ڊيمن کي ٺاهيو وڃي؟

نه. جيڪڏهن توهان ائين ڪندا ته اهو هڪ استثنا اڇلائي ڇڏيندو IllegalThreadStateException. تنهن ڪري، اسان شروع ڪرڻ کان پهريان صرف هڪ ڊيمون موضوع ٺاهي سگهون ٿا. مثال:

class SetDaemonAfterStartExample extends Thread {

   public void run() {
       System.out.println("Working...");
   }

   public static void main(String[] args) {
       SetDaemonAfterStartExample afterStartExample = new SetDaemonAfterStartExample();
       afterStartExample.start();

       // здесь будет выброшено исключение
       afterStartExample.setDaemon(true);
   }
}

ڪنسول آئوٽ:

Working...
Exception in thread "main" java.lang.IllegalThreadStateException
	at java.lang.Thread.setDaemon(Thread.java:1359)
	at SetDaemonAfterStartExample.main(SetDaemonAfterStartExample.java:14)

45. بندش ڇا آهي؟

شٽ ڊائون هوڪ هڪ ٿريڊ آهي جنهن کي JVM (جاوا ورچوئل مشين) جي بند ٿيڻ کان اڳ واضح طور سڏيو ويندو آهي. تنهن ڪري اسان ان کي استعمال ڪري سگهون ٿا هڪ وسيلن کي صاف ڪرڻ يا رياست کي بچائڻ لاءِ جڏهن جاوا ورچوئل مشين عام طور تي يا اوچتو بند ٿي وڃي. اسان shutdown hookھيٺ ڏنل طريقي سان شامل ڪري سگھون ٿا:

Runtime.getRuntime().addShutdownHook(new ShutdownHookThreadExample());

جيئن مثال ۾ ڏيکاريل آهي:

/**
* Программа, которая показывает How запустить shutdown hook тред,
* который выполнится аккурат до окончания работы JVM
*/
class ShutdownHookThreadExample extends Thread {

   public void run() {
       System.out.println("shutdown hook задачу выполнил");
   }

   public static void main(String[] args) {

       Runtime.getRuntime().addShutdownHook(new ShutdownHookThreadExample());

       System.out.println("Теперь программа засыпает, нажмите ctrl+c чтоб завершить ее.");
       try {
           Thread.sleep(60000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

ڪنسول آئوٽ:

Теперь программа засыпает, нажмите ctrl+c чтоб завершить ее.
shutdown hook задачу выполнил

46. ​​هم وقت سازي ڇا آهي؟

جاوا ۾ هم وقت سازي ڪيترن ئي موضوعن جي ڪنهن به حصيداري وسيلن تائين رسائي کي ڪنٽرول ڪرڻ جي صلاحيت آهي. جڏهن ڪيترائي ٿريڊ هڪ ئي ڪم ڪرڻ جي ڪوشش ڪندا آهن ته غلط نتيجو اچڻ جو امڪان هوندو آهي، ان ڪري ان مسئلي کي دور ڪرڻ لاءِ جاوا سنڪرونائيزيشن جو استعمال ڪندو آهي، جنهن سبب هڪ وقت ۾ صرف هڪ ٿريڊ ڪم ڪري سگهي ٿو. هم وقت سازي کي ٽن طريقن سان حاصل ڪري سگهجي ٿو:

• هم وقت سازي جو طريقو
• هڪ مخصوص بلاڪ کي هم وقت سازي ڪندي
• جامد هم وقت سازي

هم وقت سازي جو طريقو

هم وقت سازي جو طريقو استعمال ڪيو ويندو آهي ڪنهن شئي کي بند ڪرڻ لاءِ ڪنهن به گڏيل وسيلن لاءِ. جڏهن هڪ ڌاڳو هڪ هم وقت سازي طريقي کي سڏي ٿو، اهو خودڪار طريقي سان ان اعتراض تي هڪ تالا حاصل ڪري ٿو ۽ ان کي جاري ڪري ٿو جڏهن ڌاڳو پنهنجو ڪم مڪمل ڪري ٿو. ان کي ڪم ڪرڻ لاءِ، توهان کي هم وقت سازي ڪيل لفظ شامل ڪرڻ جي ضرورت آهي . اچو ته ڏسو ته اهو ڪيئن ڪم ڪري ٿو مثال سان:

/**
* Пример, где мы синхронизируем метод. То есть добавляем ему слово synchronized.
* Есть два писателя, которые хотят использовать один принтер. Они подготовor свои поэмы
* И конечно же не хотят, чтоб их поэмы перемешались, а хотят, чтоб работа была сделана по * * * очереди для каждого из них
*/
class Printer {

   synchronized void print(List<String> wordsToPrint) {
       wordsToPrint.forEach(System.out::print);
       System.out.println();
   }

   public static void main(String args[]) {
       // один an object для двух тредов
       Printer printer  = new Printer();

       // создаем два треда
       Writer1 writer1 = new Writer1(printer);
       Writer2 writer2 = new Writer2(printer);

       // запускаем их
       writer1.start();
       writer2.start();
   }
}

/**
* Писатель номер 1, который пишет свою поэму.
*/
class Writer1 extends Thread {
   Printer printer;

   Writer1(Printer printer) {
       this.printer = printer;
   }

   public void run() {
       List<string> poem = Arrays.asList("Я ", this.getName(), " Пишу", " Письмо");
       printer.print(poem);
   }

}

/**
* Писатель номер 2, который пишет свою поэму.
*/
class Writer2 extends Thread {
   Printer printer;

   Writer2(Printer printer) {
       this.printer = printer;
   }

   public void run() {
       List<String> poem = Arrays.asList("Не Я ", this.getName(), " Не пишу", " Не Письмо");
       printer.print(poem);
   }
}

۽ ڪنسول ڏانھن ٻاھر نڪتو:

Я Thread-0 Пишу Письмо
Не Я Thread-1 Не пишу Не Письмо

هم وقت سازي بلاڪ

هڪ هم وقت سازي بلاڪ استعمال ڪري سگهجي ٿو هم وقت سازي کي انجام ڏيڻ لاءِ ڪنهن مخصوص طريقي جي وسيلن تي. اچو ته هڪ وڏي طريقي سان (ها، ها، توهان اهڙيون شيون نٿا لکي سگهو، پر ڪڏهن ڪڏهن ائين ٿئي ٿو) توهان کي صرف هڪ ننڍڙو حصو هم وقت سازي ڪرڻ جي ضرورت آهي، ڪجهه سببن لاء. جيڪڏهن توهان هڪ طريقي جي سڀني ڪوڊ کي هم وقت سازي واري بلاڪ ۾ رکون ٿا، اهو ساڳيو ڪم ڪندو هڪ هم وقت سازي طريقي سان. نحو هن طرح نظر اچي ٿو:

synchronized (“an object для блокировки”) {
   // сам code, который нужно защитить
}

پوئين مثال کي نه ورجائڻ لاءِ، اسين گمنام ڪلاسز ذريعي ٿريڊ ٺاهينداسين - يعني فوري طور تي رنبل انٽرفيس کي لاڳو ڪرڻ.

/**
* Вот How добавляется блок синхронизации.
* Внутри нужно указать у кого будет взят мьютекс для блокировки.
*/
class Printer {

   void print(List<String> wordsToPrint) {
       synchronized (this) {
           wordsToPrint.forEach(System.out::print);
       }
       System.out.println();
   }

   public static void main(String args[]) {
       // один an object для двух тредов
       Printer printer = new Printer();

       // создаем два треда
       Thread writer1 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("Я ", "Writer1", " Пишу", " Письмо");
               printer.print(poem);
           }
       });
       Thread writer2 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("Не Я ", "Writer2", " Не пишу", " Не Письмо");
               printer.print(poem);
           }
       });

       // запускаем их
       writer1.start();
       writer2.start();
   }
}

}

۽ ڪنسول ڏانهن آئوٽ

Я Writer1 Пишу Письмо
Не Я Writer2 Не пишу Не Письмо

جامد هم وقت سازي

جيڪڏهن توهان هڪ جامد طريقي سان هم وقت سازي ڪريو ٿا، تالا ڪلاس تي هوندو، اعتراض تي نه. هن مثال ۾، اسان مطابقت پذير لفظ کي جامد طريقي سان لاڳو ڪريون ٿا جامد هم وقت سازي ڪرڻ لاءِ:

/**
* Вот How добавляется блок синхронизации.
* Внутри нужно указать у кого будет взят мьютекс для блокировки.
*/
class Printer {

   static synchronized void print(List<String> wordsToPrint) {
       wordsToPrint.forEach(System.out::print);
       System.out.println();
   }

   public static void main(String args[]) {

       // создаем два треда
       Thread writer1 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("Я ", "Writer1", " Пишу", " Письмо");
               Printer.print(poem);
           }
       });
       Thread writer2 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("Не Я ", "Writer2", " Не пишу", " Не Письмо");
               Printer.print(poem);
           }
       });

       // запускаем их
       writer1.start();
       writer2.start();
   }
}

۽ ڪنسول ڏانهن آئوٽ:

Не Я Writer2 Не пишу Не Письмо
Я Writer1 Пишу Письмо

47. هڪ volatile variable ڇا آهي؟

لفظ volatileملٽي ٿريڊ پروگرامنگ ۾ ٿريڊ جي حفاظت مهيا ڪرڻ لاءِ استعمال ڪيو ويندو آهي ڇاڪاڻ ته هڪ مٽائيندڙ متغير ۾ تبديلي ٻين سڀني موضوعن تي نظر ايندي آهي، تنهنڪري هڪ متغير هڪ وقت ۾ هڪ ٿريڊ ذريعي استعمال ڪري سگهجي ٿو. لفظ استعمال ڪندي، volatileتوهان ضمانت ڏئي سگھو ٿا ته متغير ٿريڊ-محفوظ هوندو ۽ شيئر ڪيل ياداشت ۾ محفوظ ڪيو ويندو، ۽ موضوع ان کي پنهنجي ڪيش ۾ نه وٺندا. اهو ڇا وانگر آهي؟

private volatile AtomicInteger count;

اسان صرف متغير ۾ شامل ڪريون ٿا volatile. پر هن جو مطلب اهو ناهي ته مڪمل ٿريڊ جي حفاظت... سڀ کان پوء، آپريشن هڪ متغير تي ايٽمي نه ٿي سگهي ٿي. پر توهان Atomicڪلاس استعمال ڪري سگهو ٿا جيڪي آپريشن کي ايٽمي طور تي انجام ڏين ٿا، اهو آهي، پروسيسر طرفان هڪ عمل ۾. اهڙا ڪيترائي ڪلاس پيڪيج ۾ ملي سگھن ٿا java.util.concurrent.atomic.

48. تعطل ڇا آهي

جاوا ۾ Deadlock multithreading جو حصو آهي. هڪ بند لاڪ اهڙي صورتحال ۾ ٿي سگهي ٿو جتي هڪ ٿريڊ ڪنهن ٻئي ٿريڊ پاران حاصل ڪيل اعتراض جي تالا تي انتظار ڪري رهيو آهي، ۽ ٻيو ٿريڊ پهرين ٿريڊ پاران حاصل ڪيل اعتراض جي تالا تي انتظار ڪري رهيو آهي. اهڙيء طرح، اهي ٻه سلسلا هڪ ٻئي جو انتظار ڪندا آهن ۽ انهن جي ڪوڊ کي جاري نه ڪندا. اچو ته هڪ مثال ڏسون جنهن ۾ هڪ ڪلاس آهي جيڪو لاڳو ڪري ٿو Runnable. اهو ان جي تعمير ڪندڙ ۾ ٻه وسيلن کي قبول ڪري ٿو. run() طريقي جي اندر، اهو انهن لاءِ هڪ هڪ ڪري لاڪ وٺندو آهي، تنهن ڪري جيڪڏهن توهان هن ڪلاس جون ٻه شيون ٺاهيون ۽ وسيلن کي مختلف آرڊرن ۾ منتقل ڪيو، ته توهان آساني سان تالا ۾ هلائي سگهو ٿا:

class DeadLock {

   public static void main(String[] args) {
       final Integer r1 = 10;
       final Integer r2 = 15;

       DeadlockThread threadR1R2 = new DeadlockThread(r1, r2);
       DeadlockThread threadR2R1 = new DeadlockThread(r2, r1);

       new Thread(threadR1R2).start();
       new Thread(threadR2R1).start();
   }
}

/**
* Класс, который принимает два ресурса.
*/
class DeadlockThread implements Runnable {

   private final Integer r1;
   private final Integer r2;

   public DeadlockThread(Integer r1, Integer r2) {
       this.r1 = r1;
       this.r2 = r2;
   }

   @Override
   public void run() {
       synchronized (r1) {
           System.out.println(Thread.currentThread().getName() + " захватил ресурс: " + r1);

           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }

           synchronized (r2) {
               System.out.println(Thread.currentThread().getName() + " захватил ресурс: " + r2);
           }
       }
   }
}

ڪنسول آئوٽ:

Первый тред захватил первый ресурс
Второй тред захватывает второй ресурс

49. تعطل کان ڪيئن بچجي؟

جنهن جي بنياد تي اسان ڄاڻون ٿا ته هڪ تعطل ڪيئن ٿئي ٿو، اسان ڪجهه نتيجا ڪڍي سگهون ٿا ...

• جيئن مٿي ڏنل مثال ۾ ڏيکاريو ويو آهي، بند لاڪ تالا جي nesting سبب هو. يعني هڪ تالا جي اندر ٻيو يا وڌيڪ هوندو آهي. ھن کان بچي سگھجي ٿو ھيٺئين طريقي سان - nesting بدران، توھان کي مٿي تي ھڪڙو نئون خلاصو شامل ڪرڻ جي ضرورت آھي ۽ تالا کي اعلي سطح تي ڏيو، ۽ nested لاڪ کي هٽايو.
• وڌيڪ بلاڪنگ اتي آهي، وڌيڪ موقعو آهي ته اتي هڪ تعطل پيدا ٿيندو. تنهن ڪري، هر دفعي توهان هڪ تالا شامل ڪيو، توهان کي سوچڻ جي ضرورت آهي ته ڇا واقعي ان جي ضرورت آهي ۽ ڇا هڪ نئون شامل ڪرڻ کان بچي سگهجي ٿو.
• استعمال ڪري ٿو Thread.join(). بند لاڪ به تڏهن ٿي سگهي ٿو جڏهن هڪ سلسلي ٻئي جي انتظار ۾ هجي. ھن مسئلي کان بچڻ لاء، توھان تي غور ڪري سگھوٿا ھڪڙي وقت جي حد مقرر ڪرڻ جو join()طريقو.
• جيڪڏهن اسان وٽ هڪ ڌاڳو آهي، اتي ڪوبه تعطل نه هوندو؛)

50. نسل جي حالت ڇا آهي؟

جيڪڏهن حقيقي ريس ۾ ڪارون انجام ڏين ٿيون، ته پوءِ ريسنگ جي اصطلاح ۾ ملٽي ٿريڊنگ، ٿريڊز ريس ۾ پرفارم ڪن ٿا. پر ڇو؟ اتي ٻه سلسلا آھن جيڪي ھلائي رھيا آھن ۽ اھي ساڳيا اعتراض تائين رسائي ڪري سگھن ٿا. ۽ اهي ساڳئي وقت رياست کي اپڊيٽ ڪرڻ جي ڪوشش ڪري سگهن ٿا. هينئر تائين سڀ ڪجهه واضح آهي، صحيح؟ تنهن ڪري موضوع يا ته حقيقي متوازي ۾ ڪم ڪن ٿا (جيڪڏهن پروسيسر ۾ هڪ کان وڌيڪ ڪور هجي) يا شرطي طور تي متوازي ۾، جڏهن پروسيسر مختصر وقت مختص ڪري ٿو. ۽ اسان انهن عملن کي ڪنٽرول نٿا ڪري سگهون، تنهن ڪري اسان ضمانت نه ٿا ڏئي سگهون ته جڏهن هڪ ٿريڊ ڪنهن شئي مان ڊيٽا پڙهي، ان کي تبديل ڪرڻ جو وقت هوندو ان کان اڳ جو ڪجهه ٻيو ٿريڊ اهو ڪري. اهڙيون مشڪلاتون تڏهن ٿينديون آهن جڏهن هي امتحان ۽ عمل جو ميلاپ ٿي ويندو آهي. هن جو ڇا مطلب آهي؟ مثال طور، اسان وٽ ifجسم ۾ هڪ اظهار آهي جنهن جي حالت پاڻ کي تبديل ڪري ٿي، اهو آهي:

int z = 0;

// проверь
if (z < 5) {
//действуй
   z = z + 5;
}

تنهن ڪري اتي هڪ صورتحال ٿي سگهي ٿي جڏهن ٻه موضوع هڪ ئي وقت ڪوڊ جي هن بلاڪ ۾ داخل ٿين ٿا جڏهن z اڃا صفر جي برابر آهي ۽ گڏجي اهي هن قدر کي تبديل ڪن ٿا. ۽ آخر ۾ اسان کي 5 جي متوقع قدر نه ملندي، پر 10. ان کان ڪيئن بچجي؟ توهان کي عمل ڪرڻ کان اڳ ۽ بعد ۾ بند ڪرڻ جي ضرورت آهي. يعني، پهرين سلسلي لاءِ بلاڪ ۾ داخل ٿيڻ لاءِ if، سڀ عمل انجام ڏيو، ان کي تبديل ڪريو، z۽ صرف پوءِ ايندڙ سلسلي کي اهو ڪرڻ جو موقعو ڏيو. پر ايندڙ موضوع بلاڪ ۾ داخل نه ٿيندو if، ڇاڪاڻ ته zاهو اڳ ۾ ئي 5 جي برابر هوندو:

// получить блокировку для z
if (z < 5) {
   z = z + 5;
}
// выпустить из блокировки z
===================================================

پيداوار جي بدران

مان چوڻ چاهيان ٿو هر ڪنهن جي مهرباني جنهن آخر تائين پڙهيو. اهو هڪ ڊگهو سفر هو ۽ توهان اهو ڪيو! هر شي واضح نه ٿي سگهي. هي ٺيڪ آهي. جيترو جلدي مون جاوا سکڻ شروع ڪيو، مان پنهنجي سر کي لپي نه سگهيو ته هڪ جامد متغير ڇا هو. پر ڪجھ به نه، مون ان سوچ سان ننڊ ڪئي، ڪجهه وڌيڪ ماخذ پڙهيا ۽ آخرڪار سمجهي ويا. هڪ انٽرويو لاءِ تيار ڪرڻ هڪ علمي معاملي کان وڌيڪ عملي آهي. تنهن ڪري، هر انٽرويو کان اڳ، توهان کي پنهنجي شين جي يادگيري کي ٻيهر ورجائڻ ۽ تازو ڪرڻ جي ضرورت آهي جيڪي توهان گهڻو ڪري استعمال نٿا ڪري سگهو.

۽ هميشه وانگر، مفيد لنڪس:

• جاوا ۾ استثنا
• جاوا ۾ ڊفالٽ طريقا
• ArrayList طبقي جو تفصيلي تجزيو
• منهنجي GitHub اڪائونٽ ۾ رڪنيت حاصل ڪريو . مان هر ڪم اتي رکان ٿو. سڀ ڪجهه مون کي سيکاريو. مثال طور، مون تازو ڊيل ڪيو Drools RuleEngine .
• چيڪ ٿيل اڻ چيڪ ٿيل استثنا
• وسيلن سان ڪوشش ڪرڻ
• آخري لفظ
• جڏهن آئون مواد تيار ڪري رهيو هوس، مون کي واقعي پسند ڪيو سائيٽ https://www.geeksforgeeks.org . اتي واقعي تمام سٺي معلومات آهي.

پڙهڻ لاءِ توهان سڀني جي مهرباني، جلد ملنداسين) منهنجو پروفائل GitHub تي