ملٽي ٿريڊنگ: ٿريڊ ڪلاس جا طريقا ڇا ڪندا آهن

سلام اڄ اسين multithreading بابت ڳالهائڻ جاري رکون ٿا. اچو ته ٿريڊ ڪلاس جو جائزو وٺون ۽ ان جا ڪجھ طريقا ڪھڙا آھن. جڏهن اسان اڳ ۾ ڪلاس جي طريقن جو اڀياس ڪيو، اسان عام طور تي صرف هي لکيو آهي: <method name> -> <what the method does>. اهو ڪم نه ڪندو Threadجي طريقن سان :) انهن وٽ وڌيڪ پيچيده منطق آهي جنهن کي توهان ڪجهه مثالن کان سواءِ سمجهي نه سگهندا.

Thread.start() طريقو

اچو ته پاڻ کي ٻيهر ورجائڻ سان شروع ڪريون. جيئن توهان کي ياد هوندو، توهان پنهنجي ڪلاس کي ورثي واري طبقي ٺاهڻ Thread۽ run()طريقي کي ختم ڪندي هڪ موضوع ٺاهي سگهو ٿا. پر اهو پاڻ شروع نه ٿيندو، يقينا. هن کي ڪرڻ لاء، اسان کي اسان جي اعتراض جو start()طريقو سڏين ٿا. اچو ته گذريل سبق مان مثال ياد ڪريون:

public class MyFirstThread extends Thread {

   @Override
   public void run() {
       System.out.println("Thread executed: " + getName());
   }
}


public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.start();
       }
   }
}

نوٽ: ٿريڊ شروع ڪرڻ لاءِ، توھان کي سڏڻ گھرجي خاصstart()طريقي جي بجاءِrun()طريقو! اهو ٺاهڻ ۾ هڪ آسان غلطي آهي، خاص طور تي جڏهن توهان پهريون ڀيرو ملٽي ٿريڊنگ پڙهڻ شروع ڪيو. اسان جي مثال ۾، جيڪڏهن توهانrun()طريقي سان 10 ڀيراstart()، توهان هن کي حاصل ڪندا:

public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.run();
       }
   }
}

اسان جي پروگرام جا نتيجا ڏسو: ٿريڊ تي عمل ڪيو ويو: ٿريڊ-0 ٿريڊ تي عمل ڪيو ويو: ٿريڊ-1 ٿريڊ تي عمل ڪيو ويو: ٽريڊ-2 ٿريڊ تي عمل ڪيو ويو: ٿريڊ-3 ٿريڊ تي عمل ڪيو ويو: ٿريڊ-4 سلسلي تي عمل ڪيو ويو: ٿريڊ-5 ٿريڊ تي عمل ڪيو ويو: ٿريڊ-6 ٿريڊ تي عمل ڪيو ويو: Thread-7 Thread executed: Thread-8 Thread executed: Thread-9 output جي ترتيب کي ڏسو: هر شي صحيح ترتيب سان ٿي رهي آهي. عجيب، ها؟ اسان کي ان جي عادت نه آهي، ڇاڪاڻ ته اسان اڳ ۾ ئي ڄاڻون ٿا ته ترتيب جنهن ۾ سلسلو شروع ۽ عمل ڪيو وڃي ٿو، اسان جي آپريٽنگ سسٽم جي اندر هڪ اعلي عقل طرفان طئي ڪيو ويندو آهي: ٿريڊ شيڊولر. ٿي سگهي ٿو اسان صرف خوش قسمت ٿي ويا آهيون؟ يقينن، هي قسمت بابت ناهي. توھان ان جي تصديق ڪري سگھوٿا پروگرام هلائڻ سان ڪجھ وڌيڪ ڀيرا. مسئلو اهو آهي ته ڪال جو run()طريقو سڌو سنئون ملٽي ٿريڊنگ سان ڪو به واسطو ناهي. انهي صورت ۾، پروگرام کي مکيه سلسلي تي عمل ڪيو ويندو، ساڳئي سلسلي جو main()طريقو جيڪو عمل ڪري ٿو. اهو صرف ڪاميابي سان ڪنسول تي 10 لائينون پرنٽ ڪيو ۽ بس. 10 موضوع شروع نه ڪيا ويا آهن. تنهن ڪري، مستقبل ۾ هن کي ياد رکو ۽ مسلسل پنهنجو پاڻ کي چيڪ ڪريو. جيڪڏھن توھان چاھيو ٿا run()ته طريقو سڏيو وڃي، ڪال ڪريو start(). اچو ته اڳتي وڌون.

Thread.sleep() طريقو

ڪجھ دير تائين موجوده سلسلي جي عمل کي معطل ڪرڻ لاء، اسان sleep()طريقو استعمال ڪندا آهيون. اهو sleep()طريقو ڪيترن ئي ملي سيڪنڊن جو هڪ دليل جي طور تي وٺندو آهي، جيڪو اشارو ڪري ٿو ته وقت جي مقدار کي ننڊ ۾ رکڻ لاء.

public class Main {

   public static void main(String[] args) throws InterruptedException {

       long start = System.currentTimeMillis();

       Thread.sleep(3000);

       System.out.println(" - How long did I sleep? \n - " + ((System.currentTimeMillis()-start)) / 1000 + " seconds");

   }
}

ڪنسول آئوٽ: - مان ڪيترو وقت سمهي رهيو آهيان؟ - 3 سيڪنڊ نوٽ: طريقو sleep()جامد آهي: اهو موجوده سلسلي کي ننڊ ڪري ٿو. اهو آهي، جيڪو هن وقت عمل ڪيو پيو وڃي. هتي هڪ ٻيو اهم نقطو آهي: هڪ سمهڻ واري سلسلي ۾ مداخلت ٿي سگهي ٿي. انهي حالت ۾، پروگرام اڇلائي ٿو هڪ InterruptedException. اسان هيٺ ڏنل مثال تي غور ڪنداسين. رستي ۾، موضوع جاڳڻ کان پوء ڇا ٿيندو؟ ڇا ان تي عمل جاري رهندو جتان ان کي ڇڏيو ويو؟ نه. هڪ ڌاڳو اُٿڻ کان پوءِ، يعني جيڪو وقت گذريو ويو آهي ان لاءِ دليل جي طور تي Thread.sleep()گذري ويو آهي، اهو هلندڙ حالت ۾ منتقل ٿئي ٿو. پر، هن جو مطلب اهو ناهي ته موضوع شيڊولر ان کي هلائي سگهندو. اهو ممڪن آهي ته ڪنهن ٻئي بي نياز سلسلي کي ترجيح ڏئي ۽ اسان جي تازي جاڳندڙ سلسلي کي ٿوري دير کان پوءِ پنهنجو ڪم جاري رکي. هن کي ياد رکڻ جي پڪ ڪريو: جاڳڻ جو مطلب اهو ناهي ته ڪم کي فوري طور تي جاري رکو!

Thread.join() طريقو

اهو join()طريقو موجوده سلسلي جي عمل کي معطل ڪري ٿو جيستائين ٻيو ٿريڊ ختم نه ٿئي. جيڪڏهن اسان وٽ 2 موضوع آهن، t1۽ t2، ۽ اسان لکون ٿا

t1.join()

ان کان پوء t2شروع نه ٿيندي جيستائين t1ان جو ڪم ختم نه ڪيو وڃي. طريقه join()استعمال ڪري سگهجي ٿو موضوعن جي عمل جي حڪم جي ضمانت لاءِ. اچو ته غور ڪريون ته اهو join()طريقو هيٺين مثال ۾ ڪيئن ڪم ڪري ٿو:

public class ThreadExample extends Thread {

   @Override
   public void run() {

       System.out.println("Thread started: " + getName());

       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("Thread " + getName() + " is finished.");
   }
}


public class Main {

   public static void main(String[] args) throws InterruptedException {

       ThreadExample t1 = new ThreadExample();
       ThreadExample t2 = new ThreadExample();

       t1.start();


 /* The second thread (t2) will start running only after the first thread (t1)
       is finished (or an exception is thrown) */
       try {
           t1.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       t2.start();

       // The main thread will continue running only after t1 and t2 have finished
       try {
           t1.join();
           t2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("All threads have finished. The program is finished.");

   }
}

اسان هڪ سادي ThreadExampleڪلاس ٺاهيو. ان جو ڪم اهو آهي ته هڪ پيغام ڏيکاري ته ٿريڊ شروع ٿي چڪو آهي، 5 سيڪنڊن لاءِ سمهي وڃو، ۽ پوءِ آخر ۾ رپورٽ ڪريو ته ڪم مڪمل ٿي ويو آهي. ڪيڪ جو ٽُڪر. بنيادي منطق Mainڪلاس ۾ آهي. تبصرو ڏسو: اسان join()طريقي سان استعمال ڪريون ٿا ڪاميابيءَ سان ٿريڊز جي ايگزيڪيوشن آرڊر کي منظم ڪرڻ لاءِ. جيڪڏهن توهان کي ياد آهي ته اسان هي موضوع ڪيئن شروع ڪيو، عملدرآمد آرڊر ٿريڊ شيڊيولر طرفان سنڀاليو ويندو آهي. اهو سلسلو هلندو آهي پنهنجي صوابديد تي: هر ڀيري مختلف انداز ۾. هتي اسان اهو طريقو استعمال ڪري رهيا آهيون جنهن جي ضمانت آهي ته t1ٿريڊ پهريان شروع ڪيو ويندو ۽ ان تي عمل ڪيو ويندو، پوءِ t2ٿريڊ، ۽ ان کان پوءِ ئي پروگرام جو مکيه سلسلو جاري رهندو. هلندو رهڻ. حقيقي پروگرامن ۾، توهان اڪثر حالتون ڳوليندا آهيو جڏهن توهان کي ڪنهن سلسلي جي عمل ۾ مداخلت ڪرڻ جي ضرورت پوندي. مثال طور، اسان جو سلسلو هلي رهيو آهي، پر اهو ڪنهن خاص واقعي يا حالت جو انتظار ڪري رهيو آهي. جيڪڏهن اهو ٿئي ٿو، ته سلسلو بند ٿي ويندو. اهو شايد سمجهه ۾ اچي ها جيڪڏهن ڪو stop()طريقو هجي ها. پر اهو ايترو سادو ناهي. هڪ دفعي هڪ دفعي، جاوا اصل ۾ هڪ طريقو هو Thread.stop()۽ هڪ سلسلي کي مداخلت ڪرڻ جي اجازت ڏني. پر اهو بعد ۾ جاوا لائبريري مان هٽايو ويو. توھان ان کي ڳولي سگھوٿا Oracle دستاويزن ۾ ۽ ڏسو ته اھو نشان لڳايو ويو آھي ختم ٿيل . ڇو؟ ڇو ته ان سلسلي کي بند ڪري ڇڏيو آهي سواءِ ٻيو ڪجهه ڪرڻ جي. مثال طور، موضوع شايد ڊيٽا سان ڪم ڪري رهيو آهي ۽ ڪجهه تبديل ڪري رهيو آهي. ان کان پوء ان جي ڪم جي وچ ۾ اوچتو ۽ unceremoniously طريقي سان ڪٽيو ويو stop(). بغير ڪنهن مناسب بندش جي، ۽ نه ئي وسيلن جي ڇڏڻ جي، نه ئي غلطي سنڀالڻ - هن مان ڪو به نه هو. ٿورڙي مبالغہ ڪرڻ لاء، stop()طريقو صرف ان جي رستي ۾ هر شيء کي تباهه ڪيو. اهو ڪمپيوٽر کي بند ڪرڻ لاءِ آئوٽليٽ مان پاور ڪنڊ ڪڍڻ وانگر هو. ها، توهان گهربل نتيجو حاصل ڪري سگهو ٿا. پر هرڪو ڄاڻي ٿو ته ڪجهه هفتن کان پوءِ ڪمپيوٽر توهان جو شڪرگذار نه ٿيندو ان طريقي سان علاج ڪرڻ لاءِ. اهو ئي سبب آهي ته جاوا ۾ موضوعن جي مداخلت لاء منطق تبديل ٿي وئي آهي ۽ هاڻي هڪ خاص interrupt()طريقو استعمال ڪري ٿو.

Thread.interrupt() طريقو

ڇا ٿيندو جيڪڏهن interrupt()طريقو هڪ موضوع تي سڏيو وڃي ٿو؟ اتي 2 امڪان آهن:

1. جيڪڏهن اعتراض انتظار جي حالت ۾ هو، مثال طور، joinيا sleepطريقن جي ڪري، پوء انتظار ۾ مداخلت ڪئي ويندي ۽ پروگرام اڇلائي ڇڏيندو InterruptedException.
2. جيڪڏهن ڌاڳو ڪم ڪندڙ حالت ۾ هو، ته پوءِ بولان interruptedپرچم اعتراض تي مقرر ڪيو ويندو.

پر اسان کي اعتراض تي هن پرچم جي قيمت کي جانچڻو پوندو ۽ صحيح طور تي پنهنجو ڪم مڪمل ڪرڻ گهرجي! ان ڪري Threadڪلاس جو طريقو آهي boolean isInterrupted(). اچو ته گھڙي جي مثال ڏانھن موٽون جيڪو بنيادي ڪورس ۾ سبق ۾ ھو. سهولت لاءِ، اسان ان کي ٿورو آسان ڪيو آهي:

public class Clock extends Thread {

   public static void main(String[] args) throws InterruptedException {
       Clock clock = new Clock();
       clock.start();

       Thread.sleep(10000);
       clock.interrupt();
   }

   public void run() {
       Thread current = Thread.currentThread();

       while (!current.isInterrupted())
       {
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               System.out.println("The thread was interrupted");
               break;
           }
           System.out.println("Tick");
       }
   }
}

انهي حالت ۾، ڪلاڪ شروع ٿئي ٿي ۽ هر سيڪنڊ کي ٽڪڻ شروع ٿئي ٿو. 10 هين سيڪنڊ ۾، اسان گھڙي جي سلسلي ۾ مداخلت ڪريون ٿا. جيئن ته توهان اڳ ۾ ئي ڄاڻو ٿا، جيڪڏهن اهو سلسلو جيڪو اسان مداخلت ڪرڻ جي ڪوشش ڪري رهيا آهيون انتظار جي رياستن مان هڪ آهي، نتيجو آهي هڪ InterruptedException. هي هڪ جانچيل استثنا آهي، تنهنڪري اسان ان کي آساني سان پڪڙي سگهون ٿا ۽ پروگرام کي ختم ڪرڻ لاءِ اسان جي منطق تي عمل ڪري سگهون ٿا. ۽ اهو صرف اهو آهي جيڪو اسان ڪيو. هتي اسان جو نتيجو آهي: ٽڪ ٽڪ ٽڪ ٽڪ ٽڪ ٽڪ ٽڪ ٽڪ ٽڪيٽ ٽڪ ڪيو ويو ته اهو Threadڪلاس جي سڀني کان اهم طريقن سان اسان جي تعارف جو تعين ڪيو ويو. سدا خوشقسمت رهو!