TechCodeview

Az operációs rendszer terminológiája szerint a mutex és a szemaforok olyan kernel erőforrások, amelyek szinkronizálási szolgáltatásokat nyújtanak, más néven szinkronizációs primitívek . A folyamatszinkronizálás fontos szerepet játszik a megosztott adatok konzisztenciájának megőrzésében. Mind a szoftveres, mind a hardveres megoldások jelen vannak a kritikus szakaszokkal kapcsolatos problémák kezelésére. A kritikus szakaszproblémák hardveres megoldásait azonban meglehetősen nehéz megvalósítani. A Mutex és a szemafor egyaránt szinkronizálási szolgáltatásokat nyújt, de nem ugyanaz.

Mi az a Mutex?

A Mutex egy kölcsönös kizárási objektum, amely szinkronizálja az erőforrásokhoz való hozzáférést. Egyedi névvel jön létre a program elején. A mutex reteszelő mechanizmus biztosítja, hogy csak egy szál tudja megszerezni a mutexet és belépni a kritikus szakaszba. Ez a szál csak akkor engedi fel a mutexet, amikor az kilép a kritikus szakaszból.

Ez egy speciális típusú bináris szemafor, amelyet a megosztott erőforrásokhoz való hozzáférés szabályozására használnak. Tartalmaz egy prioritás öröklődési mechanizmust a kiterjesztett prioritás-inverziós problémák elkerülése érdekében. Lehetővé teszi, hogy az aktuális magasabb prioritású feladatokat a lehető legrövidebb ideig blokkolt állapotban tartsák. A prioritási öröklődés azonban nem korrigálja a prioritás inverzióját, hanem csak minimalizálja annak hatását.

Példa

Ezt a következő példa segítségével mutatjuk be:

 wait (mutex); ..... Critical Section ..... signal (mutex); 

Mutex használata

A mutex kölcsönös kizárást biztosít, akár a termelő, akár a fogyasztó, aki birtokában van a kulcsnak (mutex), és folytathatja munkáját. Amíg a gyártó tölti a puffert, a felhasználónak várnia kell, és fordítva. A Mutex zárban mindig csak egy szál tud működni a teljes pufferrel.

Amikor egy program elindul, megkéri a rendszert, hogy hozzon létre egy mutex objektumot egy adott erőforráshoz. A rendszer létrehozza a mutex objektumot egyedi névvel vagy azonosítóval. Amikor a programszál használni akarja az erőforrást, lefoglalja a mutex objektum zárolását, felhasználja az erőforrást, majd használat után feloldja a mutex objektum zárolását. Ezután a következő folyamat megszerezheti a zárolást a mutex objektumon.

Eközben egy folyamat megszerezte a mutex objektum zárolását, és egyetlen más szál vagy folyamat sem férhet hozzá ehhez az erőforráshoz. Ha a mutex objektum már zárolva van, a mutex objektum zárolását meg kívánó folyamatnak várnia kell, és a rendszer sorba állítja, amíg a mutex objektumot fel nem oldja.

A Mutex előnyei

Itt vannak a mutex következő előnyei, például:

• A Mutex csak egyszerű zárak, amelyeket a kritikus szakaszba való belépés, majd kioldás előtt szereznek be.
• Mivel egy adott időpontban csak egy szál van a kritikus szakaszában, nincsenek versenyfeltételek, és az adatok mindig konzisztensek maradnak.

A Mutex hátrányai

A Mutexnek van néhány hátránya is, mint például:

• Ha egy szál zárolást kap, és alvó állapotba kerül, vagy megelőzi, akkor előfordulhat, hogy a másik szál nem mozdul előre. Ez éhezéshez vezethet.
• Nem zárolható vagy oldható fel más kontextusból, mint amelyik megszerezte.
• Egyszerre csak egy szál engedélyezhető a kritikus szakaszban.
• A normál megvalósítás foglalt várakozási állapothoz vezethet, ami a CPU-időt vesztegeti.

Mi az a szemafor?

A szemafor egyszerűen egy változó, amely nem negatív és megosztva a szálak között. A szemafor egy jelzőmechanizmus, és egy másik szál jelezheti a szemaforon várakozó szálat.

A szemafor két atomi műveletet használ,

1. Várjon: A várakozási művelet csökkenti az S argumentum értékét, ha az pozitív. Ha S negatív vagy nulla, akkor nem történik művelet.

 wait(S) { while (S<=0); s--; } < pre> <p> <strong>2. Signal for the process synchronization:</strong> The signal operation increments the value of its argument S.</p> <pre> signal(S) { S++; } </pre> <p>A semaphore either allows or reject access to the resource, depending on how it is set up.</p> <h3>Use of Semaphore</h3> <p>In the case of a single buffer, we can separate the 4 KB buffer into four buffers of 1 KB. Semaphore can be associated with these four buffers, allowing users and producers to work on different buffers simultaneously.</p> <h3>Types of Semaphore</h3> <p>Semaphore is distinguished by the operating system in two categories <strong>Counting semaphore</strong> and <strong>Binary semaphore</strong> .</p> <p> <strong>1. Counting Semaphore:</strong> The semaphore S value is initialized to the <strong>number of resources</strong> present in the system. Whenever a process wants to access the resource, it performs <strong>the wait()</strong> operation on the semaphore and <strong>decrements</strong> the semaphore value by one. When it releases the resource, it performs <strong>the signal()</strong> operation on the semaphore and <strong>increments</strong> the semaphore value by one.</p> <p>When the semaphore count goes to 0, it means the processes occupy all resources. A process needs to use a resource when the semaphore count is 0. It executes the <strong>wait()</strong> operation and gets <strong>blocked</strong> until the semaphore value becomes greater than 0.</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-3.webp" alt="Mutex vs Semaphore"> <p> <strong>2. Binary semaphore:</strong> The value of a semaphore ranges between <strong>0</strong> and <strong>1</strong> . It is similar to mutex lock, but mutex is a locking mechanism, whereas the semaphore is a signaling mechanism. In binary semaphore, if a process wants to access the resource, it performs <strong>the wait()</strong> operation on the semaphore and decrements the value of the semaphore from 1 to 0. When it releases the resource, it performs a <strong>signal</strong> <strong>()</strong> operation on the semaphore and increments its value to 1. Suppose the value of the semaphore is 0 and a process wants to access the resource. In that case, it performs <strong>wait()</strong> operation and block itself till the current process utilizing the resources releases the resource.</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-4.webp" alt="Mutex vs Semaphore"> <h3>Advantages of Semaphore</h3> <p>Here are the following advantages of semaphore, such as:</p> <ul> <li>It allows more than one thread to access the critical section.</li> <li>Semaphores are machine-independent.</li> <li>Semaphores are implemented in the machine-independent code of the microkernel.</li> <li>They do not allow multiple processes to enter the critical section.</li> <li>As there is busy and waiting in semaphore, there is never wastage of process time and resources.</li> <li>They are machine-independent, which should be run in the machine-independent code of the microkernel.</li> <li>They allow flexible management of resources.</li> </ul> <h3>Disadvantage of Semaphores</h3> <p>Semaphores also have some disadvantages, such as:</p> <ul> <li>One of the biggest limitations of a semaphore is priority inversion.</li> <li>The operating system has to keep track of all calls to wait and signal semaphore.</li> <li>Their use is never enforced, but it is by convention only.</li> <li>The Wait and Signal operations require to be executed in the correct order to avoid deadlocks in semaphore.</li> <li>Semaphore programming is a complex method, so there are chances of not achieving mutual exclusion.</li> <li>It is also not a practical method for large scale use as their use leads to loss of modularity.</li> <li>Semaphore is more prone to programmer error</li> <li>, and it may cause deadlock or violation of mutual exclusion due to programmer error.</li> </ul> <h3>Difference between Mutex and Semaphore</h3> <p>The basic difference between semaphore and mutex is that semaphore is a signalling mechanism, i.e. processes perform wait() and signal() operation to indicate whether they are acquiring or releasing the resource. In contrast, a mutex is a locking mechanism, and the process has to acquire the lock on a mutex object if it wants to acquire the resource. Here are some more differences between semaphore and mutex, such as:</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-5.webp" alt="Mutex vs Semaphore"> <br> <table class="table"> <tr> <th>Terms</th> <th>Mutex</th> <th>Semaphore</th> </tr> <tr> <td>Definition</td> <td>The mutex is a locking mechanism, as to acquire a resource, a process needs to lock the mutex object, and while releasing a resource process has to unlock the mutex object.</td> <td>Semaphore is a signalling mechanism as wait() and signal() operations performed on the semaphore variable indicate whether a process is acquiring or releasing the resource.</td> </tr> <tr> <td>Existence</td> <td>A mutex is an object.</td> <td>Semaphore is an integer variable.</td> </tr> <tr> <td>Function</td> <td>Mutex allows multiple program threads to access a single resource but not simultaneously.</td> <td>Semaphore allows multiple program threads to access a finite instance of resources.</td> </tr> <tr> <td>Ownership</td> <td>Mutex object lock is released only by the process that has acquired the lock on the mutex object.</td> <td>Semaphore value can be changed by any process acquiring or releasing the resource by performing wait() and signal() operation.</td> </tr> <tr> <td>Categorize</td> <td>Mutex is not categorized further.</td> <td>The semaphore can be categorized into counting semaphore and binary semaphore.</td> </tr> <tr> <td>Operation</td> <td>The mutex object is locked or unlocked by the process of requesting or releasing the resource.</td> <td>Semaphore value is modified using wait() and signal() operation apart from initialization.</td> </tr> <tr> <td>Resources Occupied</td> <td>If a mutex object is already locked, then the process desiring to acquire resource waits and get queued by the system till the resource is released and the mutex object gets unlocked.</td> <td>Suppose the process acquires all the resources, and no resource is free. In that case, the process desiring to acquire resource performs wait() operation on semaphore variable and blocks itself till the count of semaphore become greater than 0.</td> </tr> </table> <hr></=0);>

A szemafor vagy engedélyezi vagy elutasítja a hozzáférést az erőforráshoz, attól függően, hogy hogyan van beállítva.

A szemafor használata

Egyetlen puffer esetén a 4 KB-os puffert négy 1 KB-os pufferre választhatjuk szét. A szemafor társítható ehhez a négy pufferhez, így a felhasználók és a gyártók egyszerre dolgozhatnak különböző puffereken.

A szemafor típusai

A szemafort az operációs rendszer két kategóriába sorolja Számoló szemafor és Bináris szemafor .

1. Szemafor számlálása: A szemafor S értéke a források száma jelen van a rendszerben. Amikor egy folyamat hozzá akar férni az erőforráshoz, végrehajtja a várakozás () művelet a szemaforon és csökkentések a szemafor értékét eggyel. Amikor felszabadítja az erőforrást, akkor teljesít a jel() művelet a szemaforon és lépésekben a szemafor értékét eggyel.

Ha a szemaforok száma 0-ra megy, az azt jelenti, hogy a folyamatok minden erőforrást lefoglalnak. Egy folyamatnak akkor kell erőforrást használnia, ha a szemaforok száma 0. Végrehajtja a várjon() műveletet és kap zárolt amíg a szemafor értéke 0-nál nagyobb lesz.

2. Bináris szemafor: A szemafor értéke között mozog 0 és 1 . Hasonló a mutex zárhoz, de a mutex egy reteszelő mechanizmus, míg a szemafor egy jelzőmechanizmus. A bináris szemaforban, ha egy folyamat hozzá akar férni az erőforráshoz, akkor végrehajtja a várakozás () műveletet végez a szemaforon, és 1-ről 0-ra csökkenti a szemafor értékét. Amikor felszabadítja az erőforrást, végrehajt egy jel () műveletet a szemaforon, és 1-re növeli az értékét. Tegyük fel, hogy a szemafor értéke 0, és egy folyamat hozzá akar férni az erőforráshoz. Ebben az esetben teljesít várjon() műveletet, és blokkolja magát mindaddig, amíg az erőforrásokat használó jelenlegi folyamat fel nem engedi az erőforrást.

A szemafor előnyei

Íme a szemafor következő előnyei, például:

• Lehetővé teszi, hogy egynél több szál hozzáférjen a kritikus részhez.
• A szemaforok gépfüggetlenek.
• A szemaforok a mikrokernel gépfüggetlen kódjában vannak megvalósítva.
• Nem teszik lehetővé több folyamat belépését a kritikus szakaszba.
• Mivel a szemaforban elfoglaltság és várakozás zajlik, soha nem kell a folyamatidőt és az erőforrásokat pazarolni.
• Gépfüggetlenek, amelyeket a mikrokernel gépfüggetlen kódjában kell futtatni.
• Lehetővé teszik az erőforrások rugalmas kezelését.

A szemaforok hátránya

A szemaforoknak vannak hátrányai is, például:

• A szemafor egyik legnagyobb korlátja az elsőbbségi inverzió.
• Az operációs rendszernek nyomon kell követnie minden hívást a várakozáshoz és a szemafor jelzéséhez.
• Használatukat soha nem kényszerítik ki, de csak megállapodás alapján.
• A Várakozás és a Jelzés műveleteket a megfelelő sorrendben kell végrehajtani, hogy elkerüljük a szemafor elakadását.
• A szemafor programozás összetett módszer, így van esély arra, hogy ne valósítsuk meg a kölcsönös kizárást.
• Szintén nem praktikus módszer nagyüzemi használatra, mivel használatuk a modularitás elvesztéséhez vezet.
• A szemafor hajlamosabb a programozói hibákra
• , és ez a programozói hiba miatt elakadást vagy a kölcsönös kizárás megsértését okozhatja.

Különbség a Mutex és a Semaphore között

Az alapvető különbség a szemafor és a mutex között, hogy a szemafor egy jelzőmechanizmus, azaz a folyamatok a wait() és a signal() műveletet hajtják végre, jelezve, hogy megszerzik vagy felszabadítják az erőforrást. Ezzel szemben a mutex egy zármechanizmus, és a folyamatnak meg kell szereznie a zárolást egy mutex objektumon, ha meg akarja szerezni az erőforrást. Íme néhány további különbség a szemafor és a mutex között, például: