A livello teorico, non sono diversi semanticamente. Puoi implementare un mutex usando i semafori o viceversa (vedi qui per un esempio). In pratica, l'implementazione è diversa e offrono servizi leggermente diversi.
La differenza pratica (in termini di servizi di sistema che li circondano) è che l'implementazione di un mutex è finalizzata ad essere un meccanismo di sincronizzazione più leggero. In oracolo, i mutex sono noti come chiavistelli e i semafori sono noti come attese .
Al livello più basso, usano una sorta di test atomico e impostano il meccanismo. Questo legge il valore corrente di una posizione di memoria, calcola una sorta di condizionale e scrive un valore in quella posizione in una singola istruzione che non può essere interrotta . Ciò significa che puoi acquisire un mutex e testare per vedere se qualcun altro lo ha avuto prima di te.
Una tipica implementazione di mutex ha un processo o thread che esegue l'istruzione test-and-set e valuta se qualcos'altro ha impostato il mutex. Un punto chiave qui è che non c'è interazione con lo scheduler , quindi non abbiamo idea (e non ci interessa) chi ha impostato il blocco. Quindi rinunciamo alla nostra fascia oraria e la riproviamo quando l'attività viene riprogrammata o eseguiamo un blocco di spin . Uno spin lock è un algoritmo come:
Count down from 5000:
i. Execute the test-and-set instruction
ii. If the mutex is clear, we have acquired it in the previous instruction
so we can exit the loop
iii. When we get to zero, give up our time slice.
Quando abbiamo finito di eseguire il nostro codice protetto (noto come sezione critica ) abbiamo semplicemente impostato il valore di mutex su zero o qualunque cosa significhi "cancella". Se più attività stanno tentando di acquisire il mutex, l'attività successiva che viene pianificata dopo il rilascio del mutex avrà accesso alla risorsa. In genere si utilizzano i mutex per controllare una risorsa sincronizzata in cui l'accesso esclusivo è necessario solo per periodi di tempo molto brevi, normalmente per effettuare un aggiornamento di una struttura di dati condivisa.
Un semaforo è una struttura di dati sincronizzata (in genere utilizzando un mutex) che ha un conteggio e alcuni wrapper di chiamate di sistema che interagiscono con lo scheduler in modo leggermente più approfondito rispetto alle librerie di mutex. I semafori vengono incrementati e decrementati e utilizzati per bloccare le attività fino a quando qualcos'altro è pronto. Vedi Problema produttore / consumatore per un semplice esempio di questo. I semafori sono inizializzati su un certo valore: un semaforo binario è solo un caso speciale in cui il semaforo è inizializzato su 1. La pubblicazione su un semaforo ha l'effetto di svegliare un processo di attesa.
Un algoritmo di semaforo di base assomiglia a:
(somewhere in the program startup)
Initialise the semaphore to its start-up value.
Acquiring a semaphore
i. (synchronised) Attempt to decrement the semaphore value
ii. If the value would be less than zero, put the task on the tail of the list of tasks waiting on the semaphore and give up the time slice.
Posting a semaphore
i. (synchronised) Increment the semaphore value
ii. If the value is greater or equal to the amount requested in the post at the front of the queue, take that task off the queue and make it runnable.
iii. Repeat (ii) for all tasks until the posted value is exhausted or there are no more tasks waiting.
Nel caso di un semaforo binario la principale differenza pratica tra i due è la natura dei servizi di sistema che circondano la struttura dati effettiva.
EDIT: Come ha giustamente sottolineato Evan, gli spinlock rallenteranno un singolo processore. Utilizzeresti uno spinlock su una scatola multi-processore perché su un singolo processore il processo che tiene il mutex non lo ripristinerà mai mentre è in esecuzione un'altra attività. Gli spinlock sono utili solo su architetture multiprocessore.