Bedane antarane Mutex, Monitor, lan Semaphore

Hi! Nalika sampeyan sinau multithreading ing CodeGym, sampeyan kerep nemoni konsep "mutex" lan "monitor". Tanpa ngintip, sampeyan bisa ngomong kepiye bedane? :) Yen ya, wis rampung! Yen ora (iki paling umum), ora kaget. "Mutex" lan "monitor" sejatine konsep sing ana gandhengane. Kajaba iku, nalika maca pelajaran lan nonton video babagan multithreading ing situs web liyane, sampeyan bakal nemokake konsep liyane sing padha: "semaphore". Uga nduweni fungsi sing padha karo monitor lan mutex. Pramila kita bakal neliti telung istilah kasebut. Kita bakal ndeleng sawetara conto lan entuk pangerten sing jelas babagan carane konsep kasebut beda-beda :)

Mutex

Mutex (utawa kunci) minangka mekanisme khusus kanggo nyinkronake benang. Siji "ditempelake" ing saben obyek ing Jawa — sampeyan wis ngerti :) Ora masalah yen sampeyan nggunakake kelas standar utawa nggawe kelas sampeyan dhewe, contone, Cat lan Dog : kabeh obyek saka kabeh kelas duwe mutex . Istilah "mutex" asale saka "MUTUal EXclusion", sing nggambarake tujuane. Kaya sing wis dakkandhakake ing salah sawijining pelajaran sadurunge, mutex bisa mesthekake yen mung siji benang ing sawijine akses menyang obyek kasebut. Conto nyata mutex sing populer kalebu jamban. Nalika wong mlebu partisi jamban, dheweke ngunci lawang saka njero. Toilet kaya obyek sing bisa diakses kanthi pirang-pirang benang. Kunci ing lawang partisi kaya mutex, lan garis wong ing njaba nggambarake benang. Kunci ing lawang yaiku mutex jamban: njamin mung siji wong sing bisa mlebu. Ing tembung liyane, mung siji utas ing wektu sing bisa digunakake karo sumber daya sing dienggo bareng. Upaya dening utas liyane (wong) kanggo entuk akses menyang sumber daya sing dikuwasani bakal gagal. A mutex duwe sawetara fitur penting. Kaping pisanan , mung rong negara sing bisa: "dikunci" lan "dikunci". Iki mbantu kita ngerti cara kerjane: sampeyan bisa nggambar paralel karo variabel Boolean (bener / salah) utawa nomer binar (0/1). , negara ora bisa dikontrol langsung. Jawa ora duwe mekanisme sing ngidini sampeyan njupuk obyek kanthi jelas, entuk mutex, lan nemtokake status sing dikarepake. Ing tembung liyane, sampeyan ora bisa nindakake kaya:

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

Iki tegese sampeyan ora bisa ngeculake mutex obyek. Mung mesin Java duwe akses langsung menyang. Programer nggarap mutex liwat piranti basa kasebut.

Ngawasi

Monitor minangka "superstruktur" tambahan ing mutex. Nyatane, monitor minangka potongan kode sing "ora katon" kanggo programmer. Nalika kita ngomong babagan mutex sadurunge, kita menehi conto sing gampang:

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
       }
   }
}

Ing blok kode sing ditandhani karo tembung kunci sing disinkronake , mutex obyek obj kita entuk. Apik, kita bisa entuk kunci kasebut, nanging kepiye "perlindungan" sing diwenehake? Nalika kita ndeleng tembung sing disinkronake , apa sing ngalangi benang liyane mlebu blok kasebut? Proteksi kasebut asale saka monitor! Compiler ngowahi tembung kunci sing disinkronake dadi sawetara potongan kode khusus. Sawise maneh, ayo bali menyang conto nganggo metode doSomething () . Kita bakal nambah:

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

Mangkene apa sing kedadeyan "ing hood" sawise kompiler ngowahi kode iki:

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;
   }
}

Mesthi, iki dudu conto nyata. Ing kene, kita nggunakake kode kaya Jawa kanggo nggambarake apa sing kedadeyan ing mesin Java. Ngandika, kode pseudo iki menehi pangerten sing apik babagan apa sing kedadeyan karo obyek lan benang ing blok sing disinkronake lan carane kompiler ngowahi tembung kunci iki dadi sawetara pernyataan sing "ora katon" kanggo programmer. Sejatine, Jawa nggunakake tembung kunci sing disinkronake kanggo makili monitor . Kabeh kode sing katon tinimbang tembung kunci sing disinkronake ing conto pungkasan yaiku monitor.

Semafor

Tembung liyane sing bakal sampeyan temokake ing sinau pribadi babagan multithreading yaiku "semaphore". Ayo ngerteni apa iki lan kepiye bedane karo monitor lan mutex. Semaphore minangka alat kanggo nyinkronake akses menyang sawetara sumber. Fitur khas yaiku nggunakake counter kanggo nggawe mekanisme sinkronisasi. Counter kasebut ngandhani pirang-pirang utas sing bisa ngakses sumber daya bebarengan. Semaphore ing basa Jawa diwakili dening kelas Semaphore . Nalika nggawe obyek semaphore, kita bisa nggunakake konstruktor ing ngisor iki:

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

We pass ing ngisor iki kanggo konstruktor:

int ijin - nilai awal lan maksimum saka counter. Ing tembung liyane, parameter iki nemtokake jumlah utas bisa bebarengan ngakses sumber daya bebarengan;
• boolean fair - netepake urutan thread sing bakal entuk akses. Yen adil iku bener, banjur akses diwenehake kanggo nunggu thread ing urutan kang padha dijaluk. Yen salah, banjur urutan ditemtokake dening scheduler thread.

Conto klasik babagan panggunaan semafor yaiku masalah filsuf panedhaan. Kanggo nggampangake pangerten, kita bakal nyederhanakake sethithik. Mbayangno yen kita duwe 5 filsuf sing kudu mangan nedha awan. Kajaba iku, kita duwe siji meja sing bisa nampung ora luwih saka rong wong bebarengan. Tugas kita yaiku mangan kabeh filsuf. Ora ana sing kudu luwe, lan ora ana sing kudu "blok" saben liyane nalika nyoba njagong ing meja (kita kudu ngindhari deadlock). Mangkene apa kelas filsuf kita bakal katon:

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!");
       }
   }
}

Lan iki kode kanggo mbukak program kita:

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

Kita nggawe semafor sing counter disetel kanggo 2 kanggo marem kondisi: mung loro filsuf bisa mangan bebarengan. Yaiku, mung rong utas sing bisa mlaku bebarengan, amarga kelas Filsuf kita marisi Thread ! Metode ndarbeni () lan release () saka kelas Semaphore kontrol counter akses sawijining. Cara ndarbeni () takon semaphore kanggo akses menyang sumber daya. Yen counter punika> 0, banjur akses diwenehake lan counter wis suda dening 1. release ()cara "ngeculake" akses sing diwenehake sadurunge, bali menyang counter (nambah counter akses semaphore kanthi 1). Apa sing kita entuk nalika mbukak program kasebut? Apa masalah wis rampung? Apa para filsuf kita ora bakal perang nalika ngenteni giliran? :) Punika output console kita entuk:

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 

Kita nindakaken! Lan sanadyan Thales kudu mangan piyambak, Aku ora mikir kita wis gelo :) Sampeyan bisa uga wis ngeweruhi sawetara podho antarane mutex lan semaphore a. Pancen, dheweke duwe misi sing padha: nyinkronake akses menyang sawetara sumber. Bentenipun mung mutex obyek bisa dipikolehi mung siji utas ing siji wektu, nalika ing kasus semafor, sing nggunakake thread counter, sawetara thread bisa ngakses sumber daya bebarengan. Iki ora mung ketepakan :) A mutex bener semafor akanthi cacah 1. Ing tembung liya, iku semafor sing bisa nampung benang siji. Iki uga dikenal minangka "semaphore biner" amarga counter bisa duwe mung 2 nilai - 1 ("dikunci") lan 0 ("dikunci"). Mekaten! Nalika sampeyan bisa ndeleng, iku ora dadi bingung sawise kabeh :) Saiki, yen sampeyan pengin sinau multithreading ing liyane rinci ing Internet, iku bakal dadi luwih gampang kanggo sampeyan kanggo navigasi konsep iki. Ditemokake ing wulangan sabanjure!