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

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

ملٽي ٽريڊنگ

24. مان جاوا ۾ نئون ٿريڊ ڪيئن ٺاھيندس؟

ھڪڙو طريقو يا ٻيو، ھڪڙو موضوع ٺاھيو ويو آھي ٿريڊ ڪلاس استعمال ڪندي. پر ائين ڪرڻ جا مختلف طريقا آهن...

1. وارث java.lang.Thread .
2. java.lang.Runnable انٽرفيس کي لاڳو ڪريو - ٿريڊ ڪلاس جو ڪنسٽرڪٽر رننبل اعتراض وٺي ٿو.

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

ٿريڊ ڪلاس کي ورثي ۾ ڏيو

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

/**
* An example of how to create threads by inheriting the {@link Thread} class.
*/
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();
   }
}

ڪنسول آئوٽ پٽ ڪجهه هن طرح ٿيندو: اهو آهي، هتي پڻ اسان ڏسون ٿا ته موضوعن تي عمل نه ڪيو ويو آهي، بلڪه جيئن ته JVM انهن کي هلائڻ لاء مناسب آهي :)

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

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

/**
* An example of how to create threads from the {@link Runnable} interface.
* It's easier than easy — we implement this interface and then pass an instance of our object
* to the constructor.
*/
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();
   }
}

۽ هتي نتيجو آهي:

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

ھڪڙو عمل ۽ ھڪڙو سلسلو ھيٺ ڏنل طريقن سان مختلف آھن:

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

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

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

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

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

28. ڇا ان سلسلي کي ٻه ڀيرا هلائڻ ممڪن آهي؟

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

class DoubleStartThreadExample extends Thread {

   /**
    * Simulate the work of a thread
    */
   public void run() {
	// Something happens. At this state, this is not essential.
   }

   /**
    * Start the thread twice
    */
   public static void main(String[] args) {
       DoubleStartThreadExample doubleStartThreadExample = new DoubleStartThreadExample();
       doubleStartThreadExample.start();
       doubleStartThreadExample.start();
   }
}

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

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

ها، توهان ضرور سڏي سگهو ٿا run() طريقو، پر هڪ نئون موضوع پيدا نه ٿيندو، ۽ طريقو الڳ موضوع تي نه هلندو. انهي حالت ۾، اسان وٽ هڪ عام اعتراض آهي جيڪو هڪ عام طريقو سڏيندو آهي. جيڪڏهن اسان شروعات () طريقي جي باري ۾ ڳالهائي رهيا آهيون، پوء اهو ٻيو معاملو آهي. جڏهن اهو طريقو سڏيو ويندو آهي، JVM هڪ نئين سلسلي شروع ڪري ٿو. هي موضوع، موڙ ۾، اسان جي طريقي کي سڏي ٿو؛) ان تي يقين نه آهي؟ هتي، اها ڪوشش ڏيو:

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

       // Two ordinary methods will be called in the main thread, one after the other.
       runExample1.run();
       runExample2.run();
   }
}

۽ ڪنسول جي پيداوار هن طرح نظر ايندي: جئين توهان ڏسي سگهو ٿا، ڪو به موضوع نه ٺاهيو ويو آهي. سڀ ڪجھ ڪم ڪيو جيئن هڪ عام طبقي ۾. پهرين، پهرين اعتراض جو طريقو جاري ڪيو ويو، ۽ پوء ٻيو.

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

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

جاوا ڊيمون ٿريڊ کي ڇو ختم ڪري ٿو؟

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

ٿريڊ ڪلاس جا طريقا

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

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

مثال:

class DaemonThreadExample extends Thread {

   public void run() {
       // Checks whether this thread is a daemon
       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();

       // Make thread1 a daemon thread.
       thread1.setDaemon(true);

       System.out.println("daemon? " + thread1.isDaemon());
       System.out.println("daemon? " + thread2.isDaemon());
       System.out.println("daemon? " + thread3.isDaemon());

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

ڪنسول آئوٽ: آئوٽ پٽ مان، اسان ڏسون ٿا ته ٿريڊ جي اندر، اسان استعمال ڪري سگھون ٿا static currentThread() طريقو معلوم ڪرڻ لاءِ ته اهو ڪهڙو ٿريڊ آهي. متبادل طور تي، جيڪڏهن اسان وٽ ٿريڊ اعتراض جو حوالو آهي، اسان پڻ ان مان سڌو سنئون ڳولي سگهون ٿا. هي ترتيب ڏيڻ جي ضروري سطح فراهم ڪري ٿي.

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

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

class SetDaemonAfterStartExample extends Thread {

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

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

       // An exception will be thrown here
       afterStartExample.setDaemon(true);
   }
}

ڪنسول آئوٽ:

32. هڪ بند ٿلهو ڇا آهي؟

هڪ شٽ ڊائون ٿلهو هڪ ٿلهو آهي جنهن کي جاوا ورچوئل مشين (JVM) بند ٿيڻ کان اڳ واضح طور سڏيو ويندو آهي. اهڙيء طرح، اسان ان کي استعمال ڪري سگھون ٿا هڪ وسيلو ڇڏڻ يا رياست کي بچائڻ لاء جڏهن جاوا ورچوئل مشين عام طور تي يا غير معمولي طور تي بند ٿئي ٿي. اسان ھيٺ ڏنل طريقو استعمال ڪندي بند ٿيل ٿلهو شامل ڪري سگھون ٿا.

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

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

/**
* A program that shows how to start a shutdown hook thread,
* which will be executed right before the JVM shuts down
*/
class ShutdownHookThreadExample extends Thread {

   public void run() {
       System.out.println("shutdown hook executed");
   }

   public static void main(String[] args) {

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

       System.out.println("Now the program is going to fall asleep. Press Ctrl+C to terminate it.");
       try {
           Thread.sleep(60000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
}

ڪنسول آئوٽ:

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

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

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

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

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

/**
* An example where we synchronize a method. That is, we add the synchronized keyword to it.
* There are two authors who want to use one printer. Each of them has composed their own poems
* And of course they don’t want their poems mixed up. Instead, they want work to be performed in * * * order for each of them
*/
class Printer {

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

   public static void main(String args[]) {
       // One object for two threads
       Printer printer  = new Printer();

       // Create two threads
       Writer1 writer1 = new Writer1(printer);
       Writer2 writer2 = new Writer2(printer);

       // Start them
       writer1.start();
       writer2.start();
   }
}

/**
* Author No. 1, who writes an original poem.
*/
class Writer1 extends Thread {
   Printer printer;

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

   public void run() {
       List<string> poem = Arrays.asList("I ", this.getName(), " Write", " A Letter");
       printer.print(poem);
   }

}

/**
* Author No. 2, who writes an original poem.
*/
class Writer2 extends Thread {
   Printer printer;

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

   public void run() {
       List<String> poem = Arrays.asList("I Do Not ", this.getName(), " Not Write", " No Letter");
       printer.print(poem);
   }
}

۽ ڪنسول جي پيداوار هي آهي:

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

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

synchronized ("object to be locked") {
   // The code that must be protected
}

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

/**
* This is how a synchronization block is added.
* Inside the block, you need to specify which object's mutex will be acquired.
*/
class Printer {

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

   public static void main(String args[]) {
       // One object for two threads
       Printer printer = new Printer();

       // Create two threads
       Thread writer1 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I ", "Writer1", " Write", " A Letter");
               printer.print(poem);
           }
       });
       Thread writer2 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I Do Not ", "Writer2", " Not Write", " No Letter");
               printer.print(poem);
           }
       });

       // Start them
       writer1.start();
       writer2.start();
   }
}

}

۽ ڪنسول جي پيداوار هي آهي:

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

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

/**
* This is how a synchronization block is added.
* Inside the block, you need to specify which object's mutex will be acquired.
*/
class Printer {

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

   public static void main(String args[]) {

       // Create two threads
       Thread writer1 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I ", "Writer1", " Write", " A Letter");
               Printer.print(poem);
           }
       });
       Thread writer2 = new Thread(new Runnable() {
           @Override
           public void run() {
               List<String> poem = Arrays.asList("I Do Not ", "Writer2", " Not Write", " No Letter");
               Printer.print(poem);
           }
       });

       // Start them
       writer1.start();
       writer2.start();
   }
}

۽ ڪنسول جي پيداوار هي آهي:

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

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

private volatile AtomicInteger count;

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

35. تعطل ڇا آهي؟

جاوا ۾، تعطل اهو آهي جيڪو ڪجهه ٿي سگهي ٿو ملٽي ٿريڊنگ جي حصي طور. ڊيڊ لاڪ تڏهن ٿي سگهي ٿو جڏهن هڪ ٿريڊ ڪنهن شئي جي لاڪ جو انتظار ڪري رهيو آهي ٻئي ٿريڊ طرفان حاصل ڪيل شئي جي تالا جو، ۽ ٻيو ٿريڊ انتظار ڪري رهيو آهي اعتراض جي لاڪ لاءِ جيڪو پهرين ٿريڊ ذريعي حاصل ڪيو ويو آهي. هن جو مطلب آهي ته ٻه سلسلا هڪ ٻئي جي انتظار ۾ آهن، ۽ انهن جي ڪوڊ جي عمل جاري نه ٿي سگهي. اچو ته هڪ مثال تي غور ڪريون جنهن ۾ هڪ ڪلاس آهي جيڪو لاڳو ڪري ٿو 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();
   }
}

/**
* A class that accepts two resources.
*/
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() + " acquired resource: " + r1);

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

           synchronized (r2) {
               System.out.println(Thread.currentThread().getName() + " acquired resource: " + r2);
           }
       }
   }
}

ڪنسول آئوٽ:

36. توهان ڪيئن ڊيڊ لاڪ کان بچو ٿا؟

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

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

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

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

int z = 0;

// Check
if (z < 5) {
// Act
   z = z + 5;
}

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

// Acquire the lock for z
if (z < 5) {
   z = z + 5;
}
// Release z's lock
===================================================

نتيجي جي بدران

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

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

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

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