ملٹی تھریڈنگ: تھریڈ کلاس کے طریقے کیا کرتے ہیں۔

ہائے! آج ہم ملٹی تھریڈنگ کے بارے میں بات کرتے رہیں گے۔ آئیے تھریڈ کلاس کا جائزہ لیتے ہیں اور اس کے کچھ طریقے کیا کرتے ہیں۔ جب ہم نے پہلے کلاس کے طریقوں کا مطالعہ کیا تھا، تو ہم نے عام طور پر صرف یہ لکھا تھا: <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 تھریڈ ایکزیکیوٹڈ: تھریڈ-7 تھریڈ ایگزیکیٹڈ: تھریڈ-8 تھریڈ ایگزیکیوٹڈ: تھریڈ-9 آؤٹ پٹ کی ترتیب کو دیکھیں: سب کچھ درست ترتیب میں ہو رہا ہے۔ عجیب، ہہ؟ ہم اس کے عادی نہیں ہیں، کیونکہ ہم پہلے ہی جانتے ہیں کہ جس ترتیب میں تھریڈز شروع ہوتے ہیں اور اس پر عمل درآمد ہوتا ہے اس کا تعین ہمارے آپریٹنگ سسٹم کے اندر ایک اعلیٰ عقل سے ہوتا ہے: تھریڈ شیڈولر۔ شاید ہم خوش قسمت ہیں؟ یقینا، یہ قسمت کے بارے میں نہیں ہے. آپ پروگرام کو ایک دو بار مزید چلا کر اس کی تصدیق کر سکتے ہیں۔ مسئلہ یہ ہے کہ کال کے 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()طریقہ تھا اور اس نے تھریڈ میں خلل ڈالنے کی اجازت دی۔ لیکن بعد میں اسے جاوا لائبریری سے ہٹا دیا گیا۔ آپ اسے اوریکل دستاویزات میں تلاش کر سکتے ہیں اور دیکھ سکتے ہیں کہ اسے فرسودہ کے بطور نشان زد کیا گیا ہے ۔ کیوں؟ کیونکہ اس نے کچھ اور کیے بغیر ہی تھریڈ کو روک دیا۔ مثال کے طور پر، تھریڈ ڈیٹا کے ساتھ کام کر رہا ہو اور کچھ تبدیل کر رہا ہو۔ پھر اس کے کام کے بیچ میں اسے اچانک اور غیر رسمی 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کلاس کے سب سے اہم طریقوں سے ہمارا تعارف ختم کرتا ہے۔ اچھی قسمت!