it-swarm.it

Differenza tra semaforo e mutex binari

C'è qualche differenza tra un semaforo e mutex binari o sono essenzialmente gli stessi?

741
Nitin

SonoNONla stessa cosa. Sono usati per scopi diversi!
Sebbene entrambi i tipi di semafori abbiano uno stato pieno/vuoto e utilizzino la stessa API, il loro utilizzo è molto diverso.

Semafori di esclusione reciproca
I semafori di esclusione reciproca vengono utilizzati per proteggere le risorse condivise (struttura dati, file, ecc.).

Un semaforo Mutex è "posseduto" dall'attività che lo richiede. Se l'attività B tenta di semGive un mutex attualmente detenuto dall'attività A, la chiamata di Task B restituirà un errore e avrà esito negativo.

I mutex utilizzano sempre la seguente sequenza:

 - SemTake 
 - Sezione critica 
 - SemGive

Qui c'è un semplice esempio:

 Thread A Thread B 
 Take Mutex 
 Dati di accesso 
 ... Take Mutex <== Bloccherà 
 ... 
 Fornisci dati di accesso a Mutex <== Unblocks 
 ... 
 Fornisci mutex 

Semaforo binario
Il semaforo binario risponde a una domanda completamente diversa:

  • L'attività B è stata sospesa in attesa che succedesse qualcosa (ad esempio un sensore scattato).
  • Gli scatti del sensore e una routine di servizio di interrupt vengono eseguiti. Ha bisogno di notificare un compito del viaggio.
  • L'attività B dovrebbe essere eseguita e intraprendere le azioni appropriate per l'intervento del sensore. Quindi torna ad aspettare.

   Task A                      Task B
   ...                         Take BinSemaphore   <== wait for something
   Do Something Noteworthy
   Give BinSemaphore           do something    <== unblocks

Si noti che con un semaforo binario, è OK per B prendere il semaforo e A per darlo.
Di nuovo, un semaforo binario NON protegge una risorsa dall'accesso. L'atto di dare e prendere un semaforo sono fondamentalmente disaccoppiati.
In genere non ha molto senso per lo stesso compito, quindi dare e prendere sullo stesso semaforo binario.

635
Benoit

L'esempio della toilette è un'analogia piacevole:

Mutex:

È una chiave per un bagno Una persona può avere la chiave - occupare il bagno - al momento. Al termine, la persona dà (libera) la chiave alla prossima persona in coda.

Ufficialmente: "I mutex sono tipicamente usati per serializzare l'accesso a una sezione di codice di rientro che non può essere eseguita contemporaneamente da più di un thread.Un oggetto mutex consente solo un thread in una sezione controllata, forzando altri thread che tentano di accedere a quella sezione per aspettare che il primo thread sia uscito da quella sezione. " Rif: Symbian Developer Library

(Un mutex è in realtà un semaforo con valore 1.)

Semaforo:

È il numero di chiavi WC identiche gratuite. Esempio, diciamo che abbiamo quattro servizi igienici con serrature e chiavi identiche. Il conteggio dei semafori - il conteggio dei tasti - è impostato su 4 all'inizio (tutti e quattro i bagni sono gratuiti), quindi il valore del conteggio viene decrementato quando le persone arrivano. Se tutti i servizi igienici sono pieni, vale a dire. non ci sono chiavi libere, il conteggio del semaforo è 0. Ora, quando eq. una persona lascia la toilette, il semaforo viene aumentato a 1 (una chiave gratuita) e dato alla persona successiva in coda.

Ufficialmente: "Un semaforo limita il numero di utenti simultanei di una risorsa condivisa fino a un numero massimo.I thread possono richiedere l'accesso alla risorsa (decrementando il semaforo) e possono segnalare che hanno finito di usare la risorsa (incrementando il semaforo). " Rif: Symbian Developer Library

416
dlinsin

Il mutex può essere rilasciato solo dal thread che lo ha acquisito, mentre è possibile segnalare il semaforo da qualsiasi altro thread (o processo), quindi i semafori sono più adatti per alcuni problemi di sincronizzazione come produttore-consumatore.

Su Windows, i semafori binari sono più simili agli oggetti evento che ai mutex.

411
Mladen Janković

Bei articoli sull'argomento:

Dalla parte 2:

Il mutex è simile ai principi del semaforo binario con una differenza significativa: il principio di proprietà. La proprietà è il concetto semplice che quando un task blocca (acquisisce) un mutex solo può sbloccarlo (rilasciarlo). Se un'attività tenta di sbloccare un mutex che non ha bloccato (quindi non possiede), allora si verifica una condizione di errore e, soprattutto, il mutex non è sbloccato. Se l'oggetto di mutua esclusione non ha proprietà allora, irrilevante di come è chiamato, non è un mutex.

139
teki

Dal momento che nessuna delle risposte sopra chiarisce la confusione, ecco una cosa che ha chiarito la mia confusione.

A rigor di termini, un mutex è un meccanismo di blocco usato per sincronizzare l'accesso a una risorsa. Solo un compito (può essere un thread o un processo basato sull'astrazione del sistema operativo) può acquisire il mutex. Significa che ci sarà la proprietà associata al mutex, e solo il proprietario può rilasciare il blocco (mutex).

Il semaforo è un meccanismo di segnalazione (tipo "I am done, you can carry on"). Ad esempio, se stai ascoltando i brani (supponendo che si tratti di un'unica attività) sul tuo cellulare e allo stesso tempo che il tuo amico ti ha chiamato, verrà attivato un interrupt su cui una routine di servizio di interruzione (ISR) segnalerà l'attività di elaborazione delle chiamate al risveglio .

Fonte: http://www.geeksforgeeks.org/mutex-vs-semaphore/

92
Hemant

La loro semantica di sincronizzazione è molto diversa:

  • i mutex consentono la serializzazione dell'accesso a una determinata risorsa, cioè più thread attendono un lock, uno alla volta e, come detto in precedenza, thread owns il lock fino a quando non viene eseguito: only this thread in particolare può sbloccarlo.
  • un semaforo binario è un contatore con valore 0 e 1: un blocco di attività su di esso finché any task esegue un sem_post. Il semaforo pubblicizza che una risorsa è disponibile e fornisce il meccanismo per attendere finché non viene segnalato come disponibile.

Come tale si può vedere un mutex come un token passato dall'attività alle attività e un semaforo come semaforo del traffico (esso segnala qualcuno che può procedere).

37
ppi
  • A Mutex , per definizione, viene utilizzato per serializzare l'accesso a una sezione di codice di rientro che non può essere eseguita contemporaneamente da più di un thread.

  • A Semaphore , per definizione, limita il numero di utenti simultanei di una risorsa condivisa fino a un numero massimo

  • Un semaforo può essere un Mutex ma un Mutex non può mai essere un semaforo. Ciò significa semplicemente che un semaforo binario può essere usato come Mutex, ma un Mutex non può mai esibire la funzionalità del semaforo.

  • Sia i semafori che il Mutex (almeno il kernel più recente) non sono di natura ricorsiva.
  • Nessuno possiede i semafori, mentre i Mutex sono di proprietà e il proprietario ne è responsabile. Questa è una distinzione importante da una prospettiva di debugging.
  • Nel caso di Mutex, il thread che possiede il Mutex è responsabile della sua liberazione. Tuttavia, nel caso dei semafori, questa condizione non è richiesta. Qualsiasi altro thread può segnalare di liberare il semaforo usando s m p s (function.e_ot)

  • Un'altra differenza che sarebbe importante per gli sviluppatori è che i semafori sono a livello di sistema e rimangono sotto forma di file sul filesystem, se non diversamente ripulito. I mutex sono a livello di processo e vengono ripuliti automaticamente all'uscita di un processo.

  • La natura dei semafori consente di utilizzarli nella sincronizzazione di processi correlati e non correlati, nonché tra i thread. Mutex può essere utilizzato solo nella sincronizzazione tra thread e al più tra processi correlati (l'implementazione pthread del kernel più recente viene fornita con una funzionalità che consente l'utilizzo di Mutex tra processi correlati).
  • Secondo la documentazione del kernel, i mutex sono più leggeri rispetto ai semafori. Ciò significa che un programma con utilizzo di semaforo ha un ingombro di memoria superiore rispetto a un programma con Mutex.
  • Dal punto di vista dell'utilizzo, Mutex ha semantica più semplice rispetto ai semafori.
35
Varun Chhangani

A livello teorico, non sono differenti semanticamente. Puoi implementare un mutex usando 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 circonda) è che l'implementazione di un mutex è volta ad essere un meccanismo di sincronizzazione più leggero. In oracolo, i mutex sono noti come latch e i semafori sono noti come waits .

Al livello più basso, usano una specie di meccanismo atomico test e set . 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 è possibile acquisire un mutex e testare per vedere se qualcun altro ha avuto prima di te.

Una tipica implementazione 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 importa) di chi ha impostato il blocco. Poi rinunciamo alla nostra sezione temporale e proviamo di nuovo quando l'attività viene riprogrammata o eseguiamo un spin-lock . 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 critical section ), impostiamo il valore mutex su zero o qualunque cosa significhi 'clear'. Se più attività tentano di acquisire il mutex, l'attività successiva che viene pianificata dopo il rilascio del mutex otterrà l'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 a una struttura di dati condivisa.

Un semaforo è una struttura di dati sincronizzati (in genere utilizzando un mutex) che ha un conteggio e alcuni involucri di chiamata di sistema che interagiscono con lo scheduler in un po 'più di profondità rispetto alle librerie mutex. I semafori vengono incrementati e decrementati e usati per bloccare attività fino a quando qualcos'altro è pronto. Vedi Producer/Consumer Problem per un semplice esempio di questo. I semafori sono inizializzati in qualche modo - un semaforo binario è solo un caso speciale in cui il semaforo viene inizializzato a 1. La pubblicazione su un semaforo ha l'effetto di svegliare un processo di attesa.

Un algoritmo di semaforo di base si presenta come:

(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 Evan ha giustamente sottolineato, gli spinlock rallenteranno un singolo processore. Si utilizzerà solo uno spinlock su un box multiprocessore perché su un singolo processore il processo che contiene il mutex non lo ripristinerà mai mentre è in esecuzione un'altra attività. Gli spinlock sono utili solo su architetture multiprocessore.

Sebbene mutex e semafori siano usati come primitive di sincronizzazione, c'è una grande differenza tra loro. Nel caso del mutex, solo il thread che ha bloccato o acquisito il mutex può sbloccarlo. Nel caso di un semaforo, un thread in attesa su un semaforo può essere segnalato da un thread diverso. Alcuni sistemi operativi supportano l'utilizzo di mutex e semafori tra processi. In genere l'utilizzo viene creato nella memoria condivisa.

18
Praveen_Shukla

Mutex: Supponiamo di avere una sezione critica T1 che vuole accedervi, quindi segue i passaggi seguenti. T1:

  1. Serratura
  2. Usa la sezione critica
  3. Sbloccare

Semaforo binario: funziona in base alla segnalazione di attesa e segnale. wait (s) diminuisce il valore "s" di un valore di solito "s" viene inizializzato con il valore "1", il segnale (s) aumenta il valore "s" di uno. se il valore "s" è 1 significa che nessuno sta usando la sezione critica, quando il valore è 0 significa che la sezione critica è in uso. supponiamo che il thread T2 stia usando la sezione critica, quindi segue i passaggi seguenti. T2:

  1. wait (s) // Il valore iniziale s è uno dopo aver chiamato wait il suo valore è diminuito di uno i.e 0
  2. Usa la sezione critica
  3. segnale (i) // ora il valore viene aumentato e diventa 1

La principale differenza tra il mutex e il semaforo binario è in Mutext se thread lock la sezione critica, quindi deve sbloccare la sezione critica nessun altro thread può sbloccarlo, ma in caso di semaforo binario se un thread blocca la sezione critica usando la funzione wait (s) allora valore di s diventa "0" e nessuno può accedervi fino a quando il valore di "s" diventa 1 ma supponiamo che qualche altro segnale di chiamata di thread sia allora il valore di "s" diventa 1 e consente ad altra funzione di utilizzare la sezione critica. quindi nel thread del semaforo binario non ha la proprietà.

11
Sumit Naik

Ovviamente si usa il mutex per bloccare un dato in un thread a cui si accede da un altro thread allo stesso tempo. Supponiamo che tu abbia appena chiamato lock() e nel processo di accesso ai dati. Ciò significa che non ti aspetti nessun altro thread (o un'altra istanza dello stesso thread-code) per accedere agli stessi dati bloccati dallo stesso mutex. Cioè, se è lo stesso thread-code che viene eseguito su un'istanza di thread diversa, colpisce il lock, quindi lock() dovrebbe bloccare il flusso di controllo lì. Questo vale per un thread che utilizza un codice thread diverso, che accede anche agli stessi dati e che è anche bloccato dallo stesso mutex. In questo caso, sei ancora in procinto di accedere ai dati e potresti prendere, diciamo, altri 15 secondi per raggiungere lo sblocco mutex (in modo che l'altro thread che viene bloccato in blocco mutex si sblocchi e consentirebbe al controllo di accedere ai dati). A ogni costo, permetti a un altro thread di sbloccare lo stesso mutex e, a sua volta, consentire al thread che è già in attesa (blocco) nel blocco mutex di sbloccare e accedere ai dati? Spero che tu abbia quello che sto dicendo qui? Secondo, concordato sulla definizione universale !,

  • con "mutex" questo non può accadere. Nessun altro thread può sbloccare il blocco nella tua discussione
  • con "binary-semaphore" ciò può accadere. Qualsiasi altro thread può sbloccare il blocco nel thread

Quindi, se sei molto particolare sull'uso del semaforo binario invece del mutex, dovresti fare molta attenzione nel "mirare" i blocchi e sbloccare. Intendo dire che ogni flusso di controllo che colpisce ogni serratura dovrebbe colpire una chiamata di sblocco, inoltre non dovrebbe esserci alcun "primo sblocco", piuttosto dovrebbe essere sempre "primo blocco".

10
paxi

I mutex sono usati per "meccanismi di bloccaggio". un processo alla volta può utilizzare una risorsa condivisa

mentre

I semafori sono usati per "meccanismi di segnalazione" come "I am done, now can continued"

10
Jamshad Ahmad

Su Windows, ci sono due differenze tra mutex e semafori binari:

  1. Un mutex può essere rilasciato solo dal thread che ha la proprietà, cioè il thread che in precedenza ha chiamato la funzione Wait, (o che ha assunto la proprietà durante la sua creazione). Un semaforo può essere rilasciato da qualsiasi thread.

  2. Un thread può chiamare ripetutamente una funzione di attesa su un mutex senza bloccare. Tuttavia, se si chiama una funzione di attesa due volte su un semaforo binario senza rilasciare il semaforo intermedio, il thread si bloccherà.

10
Rich

Mito:

Un paio di articoli dice che "il semaforo binario e il mutex sono uguali" o "il semaforo con il valore 1 è mutex" ma la differenza fondamentale è che il mutex può essere rilasciato solo dal thread che lo ha acquisito, mentre è possibile segnalare il semaforo da qualsiasi altro thread

Punti chiave:

• Una discussione può acquisire più di un blocco (Mutex).

• Un mutex può essere bloccato più di una volta solo se è un mutex ricorsivo, qui lock e unlock per mutex dovrebbe essere lo stesso

• Se un thread che aveva già bloccato un mutex, prova a bloccare nuovamente il mutex, entrerà nella lista di attesa di quel mutex, il che si tradurrà in un deadlock.

• Il semaforo e il mutex binari sono simili ma non uguali.

• Mutex è un'operazione costosa a causa dei protocolli di protezione ad essa associati.

• L'obiettivo principale del mutex è ottenere l'accesso atomico o bloccare la risorsa

9
Saurabh Sinha

A Mutex controlla l'accesso a una singola risorsa condivisa. Fornisce operazioni per acquire () accesso a tale risorsa e release () it al termine.

A Semaphore controlla l'accesso a un pool condiviso di risorse. Fornisce operazioni su Wait () fino a quando una delle risorse nel pool diventa disponibile e Signal () quando viene restituita al pool.

Quando il numero di risorse che un semaforo protegge è maggiore di 1, viene chiamato Conteggio del semaforo . Quando controlla una risorsa, è chiamata a Boolean Semaphore . Un semaforo booleano equivale a un mutex.

Quindi un semaforo è un'astrazione di livello superiore rispetto a Mutex. Un Mutex può essere implementato usando un semaforo ma non viceversa.

8
Charan

La domanda modificata è - Qual è la differenza tra un mutex e un semaforo "binario" in "Linux"?

Risposta: Di seguito sono riportate le differenze - i) Ambito: l'ambito del mutex si trova all'interno di uno spazio di indirizzamento del processo che lo ha creato e viene utilizzato per la sincronizzazione dei thread. Mentre il semaforo può essere utilizzato attraverso lo spazio del processo e quindi può essere utilizzato per la sincronizzazione dei processi.

ii) Mutex è leggero e più veloce del semaforo. Futex è ancora più veloce.

iii) Mutex può essere acquisito dallo stesso thread con successo più volte con la condizione che dovrebbe rilasciarlo lo stesso numero di volte. L'altro thread che tenta di acquisire si bloccherà. Considerando che in caso di semaforo se lo stesso processo tenta di acquisirlo di nuovo, blocca come può essere acquisito solo una volta.

6
Mickey

Mutex lavora sul blocco delle regioni critiche, ma il lavoro del semaforo conta.

6
Askkan

Diff tra Binary Semaphore e Mutex: PROPRIETÀ: I semafori possono essere segnalati (inviati) anche da un proprietario non corrente. Significa che puoi semplicemente postare da qualsiasi altro thread, sebbene tu non sia il proprietario.

Il semaforo è una proprietà pubblica in corso, può essere semplicemente pubblicata da un thread non proprietario. Si prega di segnare questa differenza nelle lettere grassetto, significa molto.

5
buddingspacer

http://www.geeksforgeeks.org/archives/9102 discute nei dettagli.

Mutex è il meccanismo di blocco utilizzato per sincronizzare l'accesso a una risorsa. Semaphore è un meccanismo di segnalazione.

È fino a programmatore se lui/lei vuole usare semaforo binario al posto di mutex.

5
user1852497

In Windows la differenza è come sotto. MUTEX: processo che esegue con successo wait deve eseguire un signal e viceversa. BINARY SEMAFORES: Diversi processi possono eseguire wait o signal operation su un semaforo.

4
ajay bidari

A parte il fatto che i mutex hanno un proprietario, i due oggetti possono essere ottimizzati per un uso diverso. I mutex sono progettati per essere tenuti solo per un breve periodo; la violazione di ciò può causare prestazioni scadenti e una pianificazione ingiusta. Ad esempio, un thread in esecuzione può essere autorizzato ad acquisire un mutex, anche se un altro thread è già bloccato su di esso. I semafori possono fornire più equità, o l'equità può essere forzata usando diverse variabili di condizione.

4
jilles

Il concetto era chiaro per me dopo aver oltrepassato i post. Ma c'erano alcune domande persistenti. Quindi, ho scritto questo piccolo pezzo di codice.

Quando proviamo a dare un semaforo senza prenderlo, passa attraverso. Ma quando cerchi di dare un mutex senza prenderlo, fallisce. Ho provato questo su una piattaforma Windows. Abilitare USE_MUTEX per eseguire lo stesso codice utilizzando un MUTEX.

#include <stdio.h>
#include <windows.h>
#define xUSE_MUTEX 1
#define MAX_SEM_COUNT 1

DWORD WINAPI Thread_no_1( LPVOID lpParam );
DWORD WINAPI Thread_no_2( LPVOID lpParam );

HANDLE Handle_Of_Thread_1 = 0;
HANDLE Handle_Of_Thread_2 = 0;
int Data_Of_Thread_1 = 1;
int Data_Of_Thread_2 = 2;
HANDLE ghMutex = NULL;
HANDLE ghSemaphore = NULL;


int main(void)
{

#ifdef USE_MUTEX
    ghMutex = CreateMutex( NULL, FALSE, NULL);
    if (ghMutex  == NULL) 
    {
        printf("CreateMutex error: %d\n", GetLastError());
        return 1;
    }
#else
    // Create a semaphore with initial and max counts of MAX_SEM_COUNT
    ghSemaphore = CreateSemaphore(NULL,MAX_SEM_COUNT,MAX_SEM_COUNT,NULL);
    if (ghSemaphore == NULL) 
    {
        printf("CreateSemaphore error: %d\n", GetLastError());
        return 1;
    }
#endif
    // Create thread 1.
    Handle_Of_Thread_1 = CreateThread( NULL, 0,Thread_no_1, &Data_Of_Thread_1, 0, NULL);  
    if ( Handle_Of_Thread_1 == NULL)
    {
        printf("Create first thread problem \n");
        return 1;
    }

    /* sleep for 5 seconds **/
    Sleep(5 * 1000);

    /*Create thread 2 */
    Handle_Of_Thread_2 = CreateThread( NULL, 0,Thread_no_2, &Data_Of_Thread_2, 0, NULL);  
    if ( Handle_Of_Thread_2 == NULL)
    {
        printf("Create second thread problem \n");
        return 1;
    }

    // Sleep for 20 seconds
    Sleep(20 * 1000);

    printf("Out of the program \n");
    return 0;
}


int my_critical_section_code(HANDLE thread_handle)
{

#ifdef USE_MUTEX
    if(thread_handle == Handle_Of_Thread_1)
    {
        /* get the lock */
        WaitForSingleObject(ghMutex, INFINITE);
        printf("Thread 1 holding the mutex \n");
    }
#else
    /* get the semaphore */
    if(thread_handle == Handle_Of_Thread_1)
    {
        WaitForSingleObject(ghSemaphore, INFINITE);
        printf("Thread 1 holding semaphore \n");
    }
#endif

    if(thread_handle == Handle_Of_Thread_1)
    {
        /* sleep for 10 seconds */
        Sleep(10 * 1000);
#ifdef USE_MUTEX
        printf("Thread 1 about to release mutex \n");
#else
        printf("Thread 1 about to release semaphore \n");
#endif
    }
    else
    {
        /* sleep for 3 secconds */
        Sleep(3 * 1000);
    }

#ifdef USE_MUTEX
    /* release the lock*/
    if(!ReleaseMutex(ghMutex))
    {
        printf("Release Mutex error in thread %d: error # %d\n", (thread_handle == Handle_Of_Thread_1 ? 1:2),GetLastError());
    }
#else
    if (!ReleaseSemaphore(ghSemaphore,1,NULL) )      
    {
        printf("ReleaseSemaphore error in thread %d: error # %d\n",(thread_handle == Handle_Of_Thread_1 ? 1:2), GetLastError());
    }
#endif

    return 0;
}

DWORD WINAPI Thread_no_1( LPVOID lpParam ) 
{ 
    my_critical_section_code(Handle_Of_Thread_1);
    return 0;
}


DWORD WINAPI Thread_no_2( LPVOID lpParam ) 
{
    my_critical_section_code(Handle_Of_Thread_2);
    return 0;
}
4
Raghav Navada

Mentre un semaforo binario può essere usato come un mutex, un mutex è un caso d'uso più specifico, nel senso che solo il processo che ha bloccato il mutex dovrebbe sbloccarlo. Questo vincolo di proprietà consente di fornire protezione contro:

  • Rilascio accidentale
  • Deadlock ricorsivo
  • Task Death Deadlock

Questi vincoli non sono sempre presenti perché degradano la velocità. Durante lo sviluppo del tuo codice, puoi abilitare temporaneamente questi controlli.

per esempio. è possibile abilitare l'attributo di verifica degli errori nel mutex. Il controllo degli errori dei mutex restituisce EDEADLK se si tenta di bloccare lo stesso due volte e EPERM se si sblocca un mutex che non è il proprio.

pthread_mutex_t mutex;
pthread_mutexattr_t attr;
pthread_mutexattr_init (&attr);
pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
pthread_mutex_init (&mutex, &attr);

Una volta inizializzati, possiamo inserire questi controlli nel nostro codice in questo modo:

if(pthread_mutex_unlock(&mutex)==EPERM)
 printf("Unlock failed:Mutex not owned by this thread\n");
3
Adi06411

Mutex è utilizzato per proteggere il codice e i dati sensibili, il semaforo è utilizzato per la sincronizzazione. Puoi anche avere un uso pratico con la protezione del codice sensibile, ma potrebbe esserci il rischio che la protezione dell'altro thread venga attivata dall'operazione V.So la differenza tra bi-semaphore e mutex è la proprietà. Per esempio da toilette, Mutex è come se uno potesse entrare nel bagno e chiudere la porta, nessun altro può entrare finché l'uomo non esce, il semiforo è come quello che può entrare il bagno e chiudere la porta, ma qualcun altro potrebbe entrare chiedendo all'amministratore di aprire la porta, è ridicolo.

2
mannnnerd

I mutex hanno proprietà, a differenza dei semafori. Sebbene qualsiasi thread, nell'ambito di un mutex, possa ottenere un mutex sbloccato e bloccare l'accesso alla stessa sezione critica di codice, solo il thread che ha bloccato un mutex dovrebbe unlock it .

1
laksbv

Mutex e semaforo binario sono entrambi dello stesso uso, ma in realtà sono diversi.

In caso di mutex, solo il thread che lo ha bloccato può sbloccarlo. Se qualche altro thread arriva a bloccarlo, aspetterà.

In caso di semaphone, non è questo il caso. Il semaforo non è legato a un particolare ID thread.

1
Neeraj Sh

La risposta potrebbe dipendere dal sistema operativo di destinazione. Ad esempio, almeno un'implementazione RTOS che conosco consentirà più operazioni "get" sequenziali su un singolo mutex del sistema operativo, purché siano tutte all'interno dello stesso contesto di thread. Il multiplo deve essere sostituito da un numero uguale di put prima che un altro thread possa ottenere il mutex. Questo differisce dai semafori binari, per i quali è consentito un solo get alla volta, indipendentemente dai contesti del thread.

L'idea alla base di questo tipo di mutex è la protezione di un oggetto consentendo solo a un singolo contesto di modificare i dati alla volta. Anche se il thread ottiene il mutex e quindi chiama una funzione che modifica ulteriormente l'oggetto (e ottiene/mette il protex mutex attorno alle proprie operazioni), le operazioni dovrebbero essere comunque sicure perché stanno accadendo tutte sotto un singolo thread.

{
    mutexGet();  // Other threads can no longer get the mutex.

    // Make changes to the protected object.
    // ...

    objectModify();  // Also gets/puts the mutex.  Only allowed from this thread context.

    // Make more changes to the protected object.
    // ...

    mutexPut();  // Finally allows other threads to get the mutex.
}

Naturalmente, quando si utilizza questa funzione, è necessario essere certi che tutti gli accessi all'interno di un singolo thread siano davvero sicuri!

Non sono sicuro di quanto sia comune questo approccio o se si applichi al di fuori dei sistemi con cui sono familiare. Per un esempio di questo tipo di mutex, vedere ThreadX RTOS.

1
Casey Barker

Come molti hanno menzionato, un mutex è usato per proteggere un pezzo di codice critico (sezione critica di AKA). Acquisirai il mutex (blocco), entrerai nella sezione critica e rilascii mutex (unlock) tutto nella stessa discussione .

Mentre si utilizza un semaforo, è possibile rendere un thread in attesa su un semaforo (ad esempio il thread A), finché un altro thread (ad esempio il thread B) completa qualsiasi attività, quindi imposta il semaforo per il thread A per interrompere l'attesa e continuare il suo compito.

1
Dom045

"semaforo binario" è un aggiramento del linguaggio di programmazione per utilizzare un "semaforo" come "mutex". Apparentemente ci sono due grandi differenze:

  1. Il modo in cui chiami ognuno di loro.

  2. La lunghezza massima dell '"identificatore".

0
ilias iliadis