هڪ Mutex، هڪ مانيٽر، ۽ هڪ سيمفور جي وچ ۾ فرق

سلام جڏهن توهان CodeGym تي ملٽي ٿريڊنگ جو مطالعو ڪيو، ته توهان اڪثر ”ميوٽڪس“ ۽ ”مانيٽر“ جي تصورن سان منهن ڪيو. بغير ڏسڻ جي، ڇا توهان چئي سگهو ٿا ته اهي ڪيئن مختلف آهن؟ :) جيڪڏهن ها، سٺو ڪيو! جيڪڏهن نه (اهو سڀ کان عام آهي)، اها ڪا به تعجب ناهي. "Mutex" ۽ "مانيٽر" اصل ۾ لاڳاپيل مفهوم آهن. اضافي طور تي، جڏهن توهان سبق پڙهندا آهيو ۽ ٻين ويب سائيٽن تي multithreading بابت وڊيوز ڏسندا آهيو، توهان کي هڪ ٻيو ساڳيو تصور ملندو: "سيمفور". ان ۾ مانيٽر ۽ ميوٽيڪسز لاءِ به تمام گهڻو ساڳيو ڪم آهي. ان ڪري اسان انهن ٽنهي اصطلاحن جي تحقيق ڪرڻ وارا آهيون. اسان ڪجھه مثالن تي نظر وجهنداسين ۽ هڪ واضح سمجهه ۾ ايندا ته اهي تصور ڪيئن هڪ ٻئي کان مختلف آهن :)

ميٽيڪس

هڪ ميوٽيڪس (يا تالا) هڪ خاص ميکانيزم آهي جنهن کي هم وقت سازي ڪرڻ جي سلسلي لاءِ. ھڪڙو جاوا ۾ ھر شئي سان "منسلڪ" آھي - توھان اڳ ۾ ئي ڄاڻو ٿا ته :) ان سان ڪو فرق نٿو پوي ته توھان معياري ڪلاس استعمال ڪندا آھيو يا پنھنجون ڪلاس ٺاھيندا آھيو، مثال طور Cat ۽ Dog : سڀني ڪلاسن جي سڀني شين کي ميٽيڪس آھي . اصطلاح "mutex" "MUTual Exclusion" مان ايندو آهي، جيڪو مڪمل طور تي ان جي مقصد کي بيان ڪري ٿو. جيئن اسان اسان جي پوئين سبقن مان هڪ ۾ چيو آهي، هڪ ميوٽڪس ان کي يقيني بڻائي ٿو ته هڪ وقت ۾ صرف هڪ موضوع اعتراض تائين رسائي آهي. ميوٽڪس جو هڪ مشهور حقيقي زندگي مثال شامل آهي ٽوائليٽ. جڏهن ڪو ماڻهو ٽوائلٽ جي ورهاڱي ۾ داخل ٿئي ٿو، هو اندر کان دروازو بند ڪري ٿو. ٽوائلٽ هڪ اهڙي شئي وانگر آهي جنهن تائين ڪيترن ئي ڌاڙن ذريعي پهچائي سگهجي ٿو. ورهاڱي جي دروازي تي تالا هڪ ميوٽڪس وانگر آهي، ۽ ٻاهران ماڻهن جي قطار موضوعن جي نمائندگي ڪري ٿي. دروازي تي تالا ٽوائلٽ جو ميوٽڪس آهي: اهو يقيني بڻائي ٿو ته صرف هڪ شخص اندر داخل ٿي سگهي ٿو. ٻين لفظن ۾، هڪ وقت ۾ صرف هڪ موضوع گڏيل وسيلن سان ڪم ڪري سگهي ٿو. ٻين موضوعن (ماڻهن) پاران قبضو ڪيل وسيلن تائين رسائي حاصل ڪرڻ جي ڪوشش ناڪام ٿيندي. هڪ mutex ڪيترن ئي اهم خاصيتون آهن. پهرين ، صرف ٻه حالتون ممڪن آهن: "ان لاڪ ٿيل" ۽ "لاڪ ٿيل". هي اسان کي سمجهڻ ۾ مدد ڪري ٿو ته اهو ڪيئن ڪم ڪري ٿو: توهان Boolean متغير (سچو/غلط) يا بائنري نمبر (0/1) سان متوازي ٺاهي سگهو ٿا. ٻيو ، رياست سڌو سنئون ڪنٽرول نه ٿي سگهي. جاوا وٽ ڪو به ميکانيزم نه آهي جيڪو توهان کي واضح طور تي هڪ اعتراض وٺي، ان جي ميوٽڪس حاصل ڪري، ۽ گهربل حيثيت کي تفويض ڪري. ٻين لفظن ۾، توهان ڪجهه نه ٿا ڪري سگهو جهڙوڪ:

Object myObject = new Object();
Mutex mutex = myObject.getMutex();
mutex.free();

هن جو مطلب آهي ته توهان هڪ اعتراض جي mutex ڇڏڻ نه ٿا ڪري سگهو. صرف جاوا مشين ان تائين سڌو رسائي آهي. پروگرامر ٻوليءَ جي اوزارن ذريعي ميوٽڪس سان ڪم ڪن ٿا.

مانيٽر

هڪ مانيٽر هڪ ميوٽڪس مٿان هڪ اضافي "سپرسٽر" آهي. حقيقت ۾، مانيٽر ڪوڊ جو هڪ حصو آهي جيڪو پروگرامر ڏانهن "پوشیدہ" آهي. جڏهن اسان اڳ ۾ ميٽيڪس بابت ڳالهايو، اسان هڪ سادي مثال ڏنو:

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...some logic, available for all threads

       synchronized (obj) {

           // Logic available to just one thread at a time
       }
   }
}

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

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...some logic, available for all threads

       // Logic available to just one thread at a time
       synchronized (obj) {

           /* Do important work that requires that the object
           be accessed by only one thread */
           obj.someImportantMethod();
       }
   }
}

هتي اهو آهي جيڪو "هوڊ هيٺ" ٿيڻ کان پوءِ مرتب ڪندڙ هن ڪوڊ کي بدلائي ٿو:

public class Main {

   private Object obj = new Object();

   public void doSomething() throws InterruptedException {

       // ...some logic, available for all threads

       // Logic available to just one thread at a time:

       /* as long as the object's mutex is busy,
       all the other threads (except the one that acquired it) are put to sleep */
       while (obj.getMutex().isBusy()) {
           Thread.sleep(1);
       }

       // Mark the object's mutex as busy
       obj.getMutex().isBusy() = true;

       /* Do important work that requires that the object
       be accessed by only one thread */
       obj.someImportantMethod();

       // Free the object's mutex
       obj.getMutex().isBusy() = false;
   }
}

يقينا، هي هڪ حقيقي مثال نه آهي. هتي، اسان جاوا-جهڙو ڪوڊ استعمال ڪيو اهو ظاهر ڪرڻ لاءِ ته جاوا مشين اندر ڇا ٿئي ٿو. اهو چيو ته، هي pseudo-code هڪ بهترين سمجھ ڏئي ٿو ته اصل ۾ ڇا ٿئي ٿو اعتراض سان ۽ هم وقت سازي واري بلاڪ جي ٿريڊن سان ۽ ڪيئن گڏ ڪندڙ هن لفظ کي ڪيترن ئي بيانن ۾ تبديل ڪري ٿو جيڪي پروگرامر لاءِ ”پوشيده“ آهن. بنيادي طور تي، جاوا هڪ مانيٽر جي نمائندگي ڪرڻ لاء هم وقت سازي ڪيل لفظ استعمال ڪري ٿو . آخري مثال ۾ هم وقت سازي ڪيل لفظ جي بدران سڀ ڪوڊ ظاهر ٿئي ٿو مانيٽر.

سيمفور

ٻيو لفظ جيڪو توهان کي ملائي ٿريڊنگ جي پنهنجي ذاتي مطالعي ۾ ملندو اهو آهي "سيمفور". اچو ته اهو معلوم ڪيو ته اهو ڇا آهي ۽ اهو ڪيئن مختلف آهي مانيٽر ۽ هڪ ميوٽڪس کان. هڪ سيمفور هڪ اوزار آهي جيڪو ڪجهه وسيلن تائين رسائي کي هم وقت سازي ڪرڻ لاءِ. ان جي خاص خصوصيت اها آهي ته اها هم وقت سازي جي ميڪانيزم ٺاهڻ لاءِ هڪ ڪائونٽر استعمال ڪري ٿي. ڪائونٽر اسان کي ٻڌائي ٿو ته ڪيترا موضوع هڪ ئي وقت گڏيل وسيلن تائين رسائي ڪري سگهن ٿا. جاوا ۾ سيمفورس سيمفور ڪلاس جي نمائندگي ڪن ٿا. جڏهن سيمفور شيون ٺاهي رهيا آهيون، اسان هيٺ ڏنل تعمير ڪندڙ استعمال ڪري سگهون ٿا:

Semaphore(int permits)
Semaphore(int permits, boolean fair)

اسان ھيٺين کي ٺاھيندڙ ڏانھن منتقل ڪريون ٿا:

int permits - ڪائونٽر جي شروعاتي ۽ وڌ ۾ وڌ قيمت. ٻين لفظن ۾، هي پيٽرول اهو طئي ڪري ٿو ته ڪيترا موضوع هڪ ئي وقت ۾ گڏيل وسيلن تائين رسائي ڪري سگهن ٿا؛
• boolean fair - ترتيب قائم ڪري ٿو جنهن ۾ موضوعن تائين رسائي حاصل ٿيندي. جيڪڏهن صحيح صحيح آهي، ته پوءِ انتظار جي سلسلي تائين رسائي ڏني وئي آهي انهي ترتيب ۾ جنهن ۾ انهن درخواست ڪئي هئي. جيڪڏهن اهو غلط آهي، ته پوء ترتيب ڏنل آهي ٿريڊ شيڊولر طرفان.

سيمفور استعمال جو هڪ شاندار مثال ڊائننگ فلسفي جو مسئلو آهي. سمجھڻ جي سهولت لاء، اسان ان کي ٿورو آسان ڪنداسين. تصور ڪريو ته اسان وٽ 5 فيلسوف آهن جن کي ماني کائڻ جي ضرورت آهي. اضافي طور تي، اسان وٽ ھڪڙو ٽيبل آھي جيڪو ھڪڙي وقت ٻن ماڻھن کان وڌيڪ نه رھي سگھي ٿو. اسان جو ڪم سڀني فلسفين کي کارائڻ آهي. انهن مان ڪنهن کي به بک نه سمهڻ گهرجي، ۽ انهن مان ڪنهن کي به هڪ ٻئي کي ”بلاڪ“ نه ڪرڻ گهرجي جڏهن ميز تي ويهڻ جي ڪوشش ڪئي وڃي (اسان کي بند ٿيڻ کان پاسو ڪرڻ گهرجي). هتي اهو آهي ته اسان جي فلسفي جو طبقو ڪيئن نظر ايندو:

class Philosopher extends Thread {

   private Semaphore sem;

   // Did the philosopher eat?
   private boolean full = false;

   private String name;

   Philosopher(Semaphore sem, String name) {
       this.sem=sem;
       this.name=name;
   }

   public void run()
   {
       try
       {
           // If the philosopher has not eaten
           if (!full) {
               // Ask the semaphore for permission to run
               sem.acquire();
               System.out.println(name + " takes a seat at the table");

               // The philosopher eats
               sleep(300);
               full = true;

               System.out.println(name + " has eaten! He leaves the table");
               sem.release();

               // The philosopher leaves, making room for others
               sleep(300);
           }
       }
       catch(InterruptedException e) {
           System.out.println("Something went wrong!");
       }
   }
}

۽ هتي اسان جي پروگرام کي هلائڻ لاء ڪوڊ آهي:

public class Main {

   public static void main(String[] args) {

       Semaphore sem = new Semaphore(2);
       new Philosopher(sem, "Socrates").start();
       new Philosopher(sem,"Plato").start();
       new Philosopher(sem,"Aristotle").start();
       new Philosopher(sem, "Thales").start();
       new Philosopher(sem, "Pythagoras").start();
   }
}

اسان ھڪڙو سيمفور ٺاھيو آھي جنھن جي ڪاؤنٽر کي 2 تي مقرر ڪيو ويو آھي شرط کي پورو ڪرڻ لاء: صرف ٻه فيلسوف ھڪڙي وقت کائي سگھن ٿا. يعني هڪ ئي وقت فقط ٻه سٽون هلي سگهن ٿيون، ڇو ته اسان جي فلسفي طبقي کي ٿريڊ ورثي ۾ ملي آهي ! سيمفور ڪلاس جا acquire () ۽ ڇڏڻ () طريقا ان جي پهچ جي ڪاؤنٽر کي ڪنٽرول ڪن ٿا. حاصل () طريقو سيمفور کان پڇي ٿو وسيلن تائين رسائي لاءِ. جيڪڏهن ڪائونٽر >0 آهي، ته پوءِ پهچ ڏني ويندي آهي ۽ ڪائونٽر 1 کان گهٽجي ويندو آهي. رليز() طريقو اڳ ۾ ڏنل پهچ کي ”ريليز“ ڪري ٿو، ان کي ڪائونٽر ڏانهن موٽائي ٿو (سيمافور جي پهچ واري ڪائونٽر کي 1 وڌائي ٿو). اسان کي ڇا حاصل ٿيندو جڏهن اسان پروگرام هلائيندا آهيون؟ ڇا مسئلو حل ٿي ويو آهي؟ ڇا اسان جا فلاسافر پنهنجي موڙ جي انتظار ۾ نه وڙهندا؟ :) هتي اسان کي حاصل ڪيل ڪنسول جي پيداوار آهي:

Socrates takes a seat at the table 
Plato takes a seat at the table 
Socrates has eaten! He leaves the table
Plato has eaten! He leaves the table 
Aristotle takes a seat at the table 
Pythagoras takes a seat at the table 
Aristotle has eaten! He leaves the table
Pythagoras has eaten! He leaves the table 
Thales takes a seat at the table 
Thales has eaten! He leaves the table

اسان ڪيو! ۽ جيتوڻيڪ ٿيلس کي اڪيلو ماني کائڻي هئي، مان نه ٿو سمجهان ته اسان هن کي ناراض ڪيو آهي :) توهان شايد هڪ ميوٽڪس ۽ سيمفور جي وچ ۾ ڪجهه هڪجهڙائي محسوس ڪئي هوندي. درحقيقت، انهن جو ساڳيو مشن آهي: ڪجهه وسيلن تائين رسائي کي هم وقت سازي ڪرڻ. فرق صرف اهو آهي ته ڪنهن شئي جي ميوٽڪس کي هڪ وقت ۾ صرف هڪ ٿريڊ ذريعي حاصل ڪري سگهجي ٿو، جڏهن ته سيمفور جي صورت ۾، جيڪو ٿريڊ ڪائونٽر استعمال ڪري ٿو، ڪيترن ئي موضوعن کي گڏ ڪري وسيلن تائين رسائي حاصل ڪري سگهن ٿا. اهو صرف هڪ اتفاق نه آهي :) هڪ ميوٽڪس اصل ۾ 1 جي ڳڻپ سان هڪ سيمفور آهي. ٻين لفظن ۾، اهو هڪ سيمفور آهي جيڪو هڪ واحد موضوع کي ترتيب ڏئي سگهي ٿو. اهو پڻ "بائنري سيمفور" جي نالي سان سڃاتو وڃي ٿو، ڇاڪاڻ ته ان جي ڪائونٽر ۾ صرف 2 قيمتون ٿي سگهن ٿيون - 1 ("ان لاڪ") ۽ 0 ("بند ٿيل"). بس اهو آهي! جئين توهان ڏسي سگهو ٿا، اهو سڀ کان پوء پريشان نه آهي :) هاڻي، جيڪڏهن توهان انٽرنيٽ تي وڌيڪ تفصيل سان multithreading مطالعو ڪرڻ چاهيو ٿا، اهو توهان لاء انهن تصورن کي نيوڻ لاء ٿورو آسان ٿيندو. ايندڙ سبقن ۾ ملنداسين!