Volgens de terminologie van het besturingssysteem zijn mutex en semaforen kernelbronnen die synchronisatiediensten leveren, ook wel synchronisatieprimitieven . Processynchronisatie speelt een belangrijke rol bij het handhaven van de consistentie van gedeelde gegevens. Zowel de software- als de hardwareoplossingen zijn aanwezig voor het omgaan met kritieke sectieproblemen. Maar hardwareoplossingen voor kritieke sectieproblemen zijn vrij moeilijk te implementeren. Mutex en semafoor bieden beide synchronisatiediensten, maar ze zijn niet hetzelfde.

Wat is Mutex?

Mutex is een wederzijds uitsluitingsobject dat de toegang tot een bron synchroniseert. Het wordt aan het begin van een programma gemaakt met een unieke naam. Het mutex-vergrendelingsmechanisme zorgt ervoor dat slechts één draad de mutex kan bereiken en het kritieke gedeelte kan betreden. Deze thread geeft de mutex alleen vrij wanneer deze in de kritieke sectie wordt afgesloten.

Het is een speciaal type binaire semafoor dat wordt gebruikt voor het controleren van de toegang tot de gedeelde bron. Het omvat een mechanisme voor prioriteitsovererving om uitgebreide problemen met prioriteitsinversie te voorkomen. Hiermee kunnen huidige taken met een hogere prioriteit zo kort mogelijk in de geblokkeerde status worden gehouden. Prioriteitsovererving corrigeert echter niet de prioriteitsinversie, maar minimaliseert alleen het effect ervan.

Voorbeeld

Dit wordt weergegeven aan de hand van het volgende voorbeeld,

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

Gebruik van Mutex

Een mutex zorgt voor wederzijdse uitsluiting, zowel producent als consument, die de sleutel (mutex) kunnen hebben en door kunnen gaan met hun werk. Zolang de producent de buffer vult, moet de gebruiker wachten, en omgekeerd. Bij Mutex-vergrendeling kan altijd slechts één thread met de hele buffer werken.

Wanneer een programma start, vraagt ​​het het systeem om een ​​mutex-object voor een bepaalde bron te maken. Het systeem maakt het mutex-object aan met een unieke naam of ID. Telkens wanneer de programmathread de bron wil gebruiken, bezet deze de vergrendeling op het mutex-object, gebruikt de bron en na gebruik wordt de vergrendeling op het mutex-object opgeheven. Vervolgens mag het volgende proces de vergrendeling op het mutex-object verkrijgen.

Ondertussen heeft een proces de vergrendeling van het mutex-object verkregen en heeft geen enkele andere thread of proces toegang tot die bron. Als het mutex-object al is vergrendeld, moet het proces dat de vergrendeling op het mutex-object wil verkrijgen, wachten en wordt door het systeem in de wachtrij geplaatst totdat het mutex-object is ontgrendeld.

Voordelen van Mutex

Hier zijn de volgende voordelen van de mutex, zoals:

• Mutex bestaat uit eenvoudige sloten die worden verkregen voordat het kritieke gedeelte wordt betreden en vervolgens wordt vrijgegeven.
• Omdat zich op elk moment slechts één thread in de kritieke sectie bevindt, zijn er geen racecondities en blijven de gegevens altijd consistent.

Nadelen van Mutex

Mutex heeft ook enkele nadelen, zoals:

• Als een thread wordt vergrendeld en in de slaapstand gaat of wordt gepreëmpteerd, kan de andere thread niet verder gaan. Dit kan tot hongersnood leiden.
• Het kan niet worden vergrendeld of ontgrendeld vanuit een andere context dan degene waarin het is verkregen.
• Er mag slechts één thread tegelijk in de kritieke sectie worden toegestaan.
• De normale implementatie kan leiden tot een drukke wachtstatus, waardoor CPU-tijd wordt verspild.

Wat is Semafoor?

Semafoor is eenvoudigweg een variabele die niet-negatief is en wordt gedeeld tussen threads. Een semafoor is een signaleringsmechanisme en een andere thread kan een thread signaleren die op een semafoor wacht.

Een semafoor gebruikt twee atomaire operaties,

1. Wacht: De wachtoperatie verlaagt de waarde van zijn argument S als deze positief is. Als S negatief of nul is, wordt er geen bewerking uitgevoerd.

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

Een semafoor staat toegang tot de bron toe of weigert deze, afhankelijk van hoe deze is ingesteld.

Gebruik van Semafoor

In het geval van een enkele buffer kunnen we de buffer van 4 KB opdelen in vier buffers van 1 KB. Semaphore kan aan deze vier buffers worden gekoppeld, waardoor gebruikers en producenten tegelijkertijd aan verschillende buffers kunnen werken.

Soorten seinpaal

Semaphore onderscheidt zich door het besturingssysteem in twee categorieën Semafoor tellen En Binaire semafoor .

1. Semafoor tellen: De semafoor S-waarde wordt geïnitialiseerd op de aantal middelen aanwezig in het systeem. Wanneer een proces toegang wil krijgen tot de bron, voert het een prestatie uit het wachten() operatie op de seinpaal en neemt af de semafoorwaarde met één. Wanneer het de bron vrijgeeft, presteert het het signaal() operatie op de seinpaal en verhogingen de semafoorwaarde met één.

Wanneer het aantal semaforen naar 0 gaat, betekent dit dat de processen alle bronnen in beslag nemen. Een proces moet een bron gebruiken als het aantal semaforen 0 is. Het voert de wachten() operatie en krijgt geblokkeerd totdat de semafoorwaarde groter wordt dan 0.

2. Binaire semafoor: De waarde van een semafoor varieert tussen 0 En 1 . Het is vergelijkbaar met het mutex-slot, maar mutex is een vergrendelingsmechanisme, terwijl de semafoor een signaalmechanisme is. Als een proces in binaire semafoor toegang wil krijgen tot de bron, presteert het het wachten() bewerking op de semafoor en verlaagt de waarde van de semafoor van 1 naar 0. Wanneer de bron wordt vrijgegeven, voert deze een signaal () bewerking op de semafoor en verhoogt de waarde ervan naar 1. Stel dat de waarde van de semafoor 0 is en een proces toegang wil krijgen tot de bron. In dat geval presteert het wachten() werking en blokkeert zichzelf totdat het huidige proces dat gebruikmaakt van de bronnen, de bron vrijgeeft.

Voordelen van Semafoor

Hier zijn de volgende voordelen van semafoor, zoals:

• Hierdoor heeft meer dan één thread toegang tot de kritieke sectie.
• Semaforen zijn machine-onafhankelijk.
• Semaforen worden geïmplementeerd in de machine-onafhankelijke code van de microkernel.
• Ze staan ​​niet toe dat meerdere processen de kritieke sectie binnendringen.
• Omdat het druk is en wacht op de seinpaal, is er nooit sprake van verspilling van procestijd en middelen.
• Ze zijn machine-onafhankelijk, wat moet worden uitgevoerd in de machine-onafhankelijke code van de microkernel.
• Ze maken een flexibel beheer van hulpbronnen mogelijk.

Nadeel van seinpalen

Semaforen hebben ook enkele nadelen, zoals:

• Een van de grootste beperkingen van een semafoor is prioriteitsomkering.
• Het besturingssysteem moet alle wachtoproepen bijhouden en de semafoor signaleren.
• Het gebruik ervan wordt nooit afgedwongen, maar alleen volgens afspraak.
• De Wait- en Signal-operaties moeten in de juiste volgorde worden uitgevoerd om impasses in de semafoor te voorkomen.
• Semafoorprogrammering is een complexe methode, dus de kans bestaat dat wederzijdse uitsluiting niet wordt bereikt.
• Het is ook geen praktische methode voor grootschalig gebruik, aangezien het gebruik ervan leidt tot verlies aan modulariteit.
• Semafoor is gevoeliger voor programmeerfouten
• , en het kan een impasse of overtreding van de wederzijdse uitsluiting veroorzaken als gevolg van een programmeerfout.

Verschil tussen Mutex en Semafoor

Het fundamentele verschil tussen semafoor en mutex is dat semafoor een signaleringsmechanisme is, dat wil zeggen dat processen wait() en signal() uitvoeren om aan te geven of ze de bron verwerven of vrijgeven. Een mutex is daarentegen een vergrendelingsmechanisme en het proces moet de vergrendeling van een mutex-object verwerven als het de bron wil verwerven. Hier zijn nog enkele verschillen tussen semafoor en mutex, zoals: