Secondo la terminologia del sistema operativo, mutex e semafori sono risorse del kernel che forniscono servizi di sincronizzazione, chiamati anche primitive di sincronizzazione . La sincronizzazione dei processi svolge un ruolo importante nel mantenere la coerenza dei dati condivisi. Sono presenti sia le soluzioni software che hardware per la gestione dei problemi delle sezioni critiche. Ma le soluzioni hardware per i problemi delle sezioni critiche sono piuttosto difficili da implementare. Mutex e semaforo forniscono entrambi servizi di sincronizzazione, ma non sono la stessa cosa.

Cos'è Mutex?

Mutex è un oggetto di mutua esclusione che sincronizza l'accesso a una risorsa. Viene creato con un nome univoco all'inizio di un programma. Il meccanismo di blocco del mutex garantisce che solo un thread possa acquisire il mutex ed entrare nella sezione critica. Questo thread rilascia il mutex solo quando esce nella sezione critica.

È un tipo speciale di semaforo binario utilizzato per controllare l'accesso alla risorsa condivisa. Include un meccanismo di ereditarietà delle priorità per evitare problemi estesi di inversione delle priorità. Consente di mantenere le attività attuali con priorità più elevata nello stato bloccato per il minor tempo possibile. Tuttavia, l'ereditarietà della priorità non corregge l'inversione della priorità ma ne minimizza solo l'effetto.

Esempio

Ciò viene mostrato con l'aiuto del seguente esempio,

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

Uso del mutex

Un mutex prevede la mutua esclusione, sia il produttore che il consumatore che possono avere la chiave (mutex) e procedere con il proprio lavoro. Finché il produttore riempie il buffer, l'utente deve attendere e viceversa. Nel blocco Mutex, sempre, solo un singolo thread può funzionare con l'intero buffer.

Quando un programma viene avviato, richiede al sistema di creare un oggetto mutex per una determinata risorsa. Il sistema crea l'oggetto mutex con un nome o ID univoco. Ogni volta che il thread del programma desidera utilizzare la risorsa, occupa il blocco sull'oggetto mutex, utilizza la risorsa e dopo l'uso rilascia il blocco sull'oggetto mutex. Quindi al processo successivo è consentito acquisire il blocco sull'oggetto mutex.

Nel frattempo, un processo ha acquisito il blocco sull'oggetto mutex e nessun altro thread o processo può accedere a quella risorsa. Se l'oggetto mutex è già bloccato, il processo che desidera acquisire il blocco sull'oggetto mutex deve attendere e viene messo in coda dal sistema finché l'oggetto mutex non viene sbloccato.

Vantaggi del Mutex

Ecco i seguenti vantaggi del mutex, come ad esempio:

• Mutex non è altro che semplici blocchi ottenuti prima di entrare nella sua sezione critica e poi rilasciarla.
• Poiché in un dato momento solo un thread si trova nella sezione critica, non esistono condizioni di competizione e i dati rimangono sempre coerenti.

Svantaggi del Mutex

Mutex presenta anche alcuni svantaggi, come:

• Se un thread ottiene un blocco e va in modalità sospensione o viene interrotto, l'altro thread potrebbe non andare avanti. Ciò può portare alla fame.
• Non può essere bloccato o sbloccato da un contesto diverso da quello che lo ha acquisito.
• Nella sezione critica dovrebbe essere consentito un solo thread alla volta.
• La normale implementazione può portare a uno stato di attesa occupato, che fa sprecare tempo alla CPU.

Cos'è il semaforo?

Il semaforo è semplicemente una variabile non negativa e condivisa tra i thread. Un semaforo è un meccanismo di segnalazione e un altro thread può segnalare un thread in attesa su un semaforo.

Un semaforo utilizza due operazioni atomiche,

1. Aspetta: L'operazione di attesa diminuisce il valore del suo argomento S se è positivo. Se S è negativo o zero, non viene eseguita alcuna operazione.

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

Un semaforo consente o rifiuta l'accesso alla risorsa, a seconda di come è impostato.

Uso del semaforo

Nel caso di un singolo buffer, possiamo separare il buffer da 4 KB in quattro buffer da 1 KB. Il semaforo può essere associato a questi quattro buffer, consentendo agli utenti e ai produttori di lavorare su buffer diversi contemporaneamente.

Tipi di semaforo

Semaphore si distingue per il sistema operativo in due categorie Conteggio del semaforo E Semaforo binario .

1. Conteggio del semaforo: Il valore del semaforo S viene inizializzato su numero di risorse presenti nel sistema. Ogni volta che un processo vuole accedere alla risorsa, esegue l'attesa() operazione sul semaforo e decrementi il valore del semaforo per uno. Quando rilascia la risorsa, esegue il segnale() operazione sul semaforo e incrementi il valore del semaforo per uno.

Quando il conteggio dei semafori arriva a 0, significa che i processi occupano tutte le risorse. Un processo deve utilizzare una risorsa quando il conteggio del semaforo è 0. Esegue il file Aspettare() operazione e ottiene bloccato finché il valore del semaforo diventa maggiore di 0.

2. Semaforo binario: Il valore di un semaforo è compreso tra 0 E 1 . È simile al mutex lock, ma il mutex è un meccanismo di blocco, mentre il semaforo è un meccanismo di segnalazione. Nel semaforo binario, se un processo vuole accedere alla risorsa, lo esegue l'attesa() operazione sul semaforo e decrementa il valore del semaforo da 1 a 0. Quando rilascia la risorsa esegue un'operazione segnale () operazione sul semaforo e ne incrementa il valore a 1. Supponiamo che il valore del semaforo sia 0 e che un processo voglia accedere alla risorsa. In tal caso, funziona Aspettare() operazione e si blocca finché il processo corrente che utilizza le risorse non rilascia la risorsa.

Vantaggi del semaforo

Ecco i seguenti vantaggi del semaforo, come ad esempio:

• Consente a più di un thread di accedere alla sezione critica.
• I semafori sono indipendenti dalla macchina.
• I semafori sono implementati nel codice indipendente dalla macchina del microkernel.
• Non consentono a più processi di entrare nella sezione critica.
• Poiché il semaforo è occupato e in attesa, non vi è mai spreco di tempo e risorse di processo.
• Sono indipendenti dalla macchina, che dovrebbero essere eseguiti nel codice indipendente dalla macchina del microkernel.
• Consentono una gestione flessibile delle risorse.

Svantaggio dei semafori

I semafori presentano anche alcuni svantaggi, come:

• Uno dei maggiori limiti di un semaforo è l'inversione della priorità.
• Il sistema operativo deve tenere traccia di tutte le chiamate in attesa e segnalare al semaforo.
• Il loro utilizzo non è mai imposto, ma è solo per convenzione.
• Le operazioni Wait e Signal devono essere eseguite nell'ordine corretto per evitare blocchi nel semaforo.
• La programmazione del semaforo è un metodo complesso, quindi è possibile che non si raggiunga la mutua esclusione.
• Inoltre, non è un metodo pratico per un utilizzo su larga scala poiché il loro utilizzo porta alla perdita di modularità.
• Il semaforo è più incline agli errori del programmatore
• e potrebbe causare un blocco o una violazione della mutua esclusione a causa di un errore del programmatore.

Differenza tra Mutex e Semaforo

La differenza fondamentale tra semaforo e mutex è che il semaforo è un meccanismo di segnalazione, ovvero i processi eseguono operazioni wait() e signal() per indicare se stanno acquisendo o rilasciando la risorsa. Al contrario, un mutex è un meccanismo di blocco e il processo deve acquisire il blocco su un oggetto mutex se desidera acquisire la risorsa. Ecco alcune altre differenze tra semaforo e mutex, come ad esempio: