it-swarm-eu.dev

Rozdíl mezi binárním semaforem a mutexem

Existuje nějaký rozdíl mezi binárním semaforem a mutexem nebo jsou v podstatě stejné?

741
Nitin

Oni jsouNEto samé. Používají se pro různé účely!
Zatímco oba typy semaforů mají stav plný/prázdný a používají stejné API, jejich použití je velmi odlišné.

Semafory vzájemného vyloučení
Semafory vzájemného vyloučení se používají k ochraně sdílených prostředků (datová struktura, soubor atd.).

Semexor Mutex je "vlastněn" úkolem, který jej vezme. Pokud se úloha B pokusí o semGive mutex, který je aktuálně uložen v úkolu A, volání úlohy B vrátí chybu a selže.

Mutexes vždy používá následující postup:

 - SemTake 
 - Kritická sekce 
 - SemGive

Zde je jednoduchý příklad:

 Závit A Závit B 
 Vezměte Mutex 
 Přístupová data 
 ... Take Mutex <== Bude blokovat 
 ... 
 Uveďte přístupová data Mutex <== Unblocks 
 ... 
 Dejte Mutex 

Binární semafor
Binární semafor řeší zcela jinou otázku:

  • Úloha B se čeká, až se něco stane (např. Sepne senzor).
  • Výlety snímače a rutinní běh služby přerušení. Musí oznámit úkol cesty.
  • Úloha B by měla běžet a podniknout příslušné kroky pro vypnutí senzoru. Pak se vraťte k čekání.

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

Všimněte si, že s binárním semaforem je v pořádku, aby B vzala semafor a A jej dala.
Opět platí, že binární semafor NENÍ chrání zdroj před přístupem. Akt dávat a brát semafor je v zásadě oddělen.
Pro stejný úkol to obvykle nedává smysl, takže dávají a berou stejný binární semafor.

635
Benoit

Příklad WC je příjemná analogie:

Mutex:

Je klíčem k záchodě. Jedna osoba může mít klíč - zabírat toaletu - v té době. Po dokončení daná osoba uvolní (uvolní) klíč další osobě ve frontě.

Oficiálně: "Mutexes se typicky používají k sériovému přístupu k části re-entrantu kódu, který nelze provést souběžně více než jedním vláknem. Objekt mutex umožňuje pouze jedno vlákno do řízené sekce, což nutí ostatní vlákna, která se snaží získat přístup k tuto sekci čekat, až první vlákno opustí tuto sekci. " Ref: Symbian Developer Library

(Mutex je opravdu semafor s hodnotou 1.)

Semafor:

Je počet volných identických toaletních klíčů. Řekněme, že máme čtyři toalety s identickými zámky a klíči. Počet semaforů - počet klíčů - je na začátku nastaven na 4 (všechny čtyři toalety jsou volné), pak se hodnota počítání snižuje, když lidé přicházejí. Pokud jsou všechny toalety plné, tzn. nejsou žádné volné klávesy vlevo, počet semaforů je 0. Nyní, když eq. jedna osoba opustí toaletu, semafor je zvětšen k 1 (jeden volný klíč), a daný další osobě ve frontě.

Oficiálně: "Semafor omezuje počet současných uživatelů sdíleného prostředku až na maximální počet. Vlákna mohou žádat o přístup ke zdroji (snížení semaforu) a mohou signalizovat, že dokončili použití zdroje (zvýšení semaforu). " Ref: Symbian Developer Library

416
dlinsin

Mutex může být uvolněn pouze vláknem, které ho získalo, zatímco semafor můžete signalizovat z jakéhokoliv jiného vlákna (nebo procesu), takže semafory jsou vhodnější pro některé problémy se synchronizací, jako jsou například výrobci-spotřebitelé.

V systému Windows jsou binární semafory spíše objekty událostí než mutexy.

411
Mladen Janković

Pěkné články na toto téma:

Od části 2:

Mutex je podobný principům binárního semaforu s jedním významným rozdílem: princip vlastnictví. Vlastnictví je jednoduchý koncept, že když úkol uzamkne (získá) mutex pouze to může odemknout (uvolnit) to. Pokud se úloha pokusí odemknout mutex, není uzamčena (tedy nevlastní), potom se vyskytne chybový stav a nejdůležitější je, že mutex není odemčen. Pokud objekt vzájemného vyloučení nemá vlastnictví, pak je irelevantní, co se nazývá, není mutex.

139
teki

Vzhledem k tomu, že žádná z výše uvedených odpovědí nevyřeší zmatek, tady je ten, který mi odstranil zmatek.

Přísně vzato, mutex je uzamykací mechanismus slouží k synchronizaci přístupu ke zdroji. Pouze jeden úkol (může být vlákno nebo proces založený na abstrakci OS) může získat mutex. Znamená to, že bude existovat vlastnictví spojené s mutexem a pouze vlastník může uvolnit zámek (mutex).

Semafor je signalizační mechanismus (“Já jsem hotový, můžete pokračovat” druh signálu). Pokud například posloucháte skladby (předpokládejte, že je to jeden úkol) ve vašem mobilu a zároveň vás váš přítel zavolal, bude spuštěno přerušení, na které bude rutina přerušení služby (ISR) signalizovat úlohu zpracování volání k probuzení. .

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

92
Hemant

Jejich sémantika synchronizace je velmi odlišná:

  • mutexy umožňují serializaci přístupu k danému zdroji, tj. více vláken čeká na zámek, po jednom a jak již bylo řečeno, vlákno vlastní zámek, dokud není provedeno: pouze toto konkrétní vlákno odemknout.
  • binární semafor je čítač s hodnotou 0 a 1: úloha, která na něm blokuje, dokud any task neprovede sem_post. Semafor inzeruje, že zdroj je k dispozici, a poskytuje mechanismus, který čeká, až bude signalizován jako dostupný.

Jako takový může vidět mutex jako token předaný z úkolu na úkoly a semafor jako dopravní červené světlo (to signály někdo, že může pokračovat).

37
ppi
  • A Mutex , podle definice, se používá k serializaci přístupu k části re-entrant kódu, který nemůže být proveden souběžně více než jedním vláknem.

  • A Semafor , podle definice, omezuje počet současných uživatelů sdíleného zdroje až na maximální počet

  • Semafor může být Mutex, ale Mutex nemůže být nikdy semaforem. To jednoduše znamená, že binární semafor může být použit jako Mutex, ale Mutex nemůže nikdy vykazovat funkčnost semaforu.

  • Semafory i Mutex (přinejmenším nejnovější jádro) jsou v přírodě neregenerativní.
  • Nikdo nevlastní semafory, zatímco Mutex je vlastněn a vlastník je za ně zodpovědný. Toto je důležitý rozdíl od perspektivy ladění.
  • V případě, že je Mutex, vlákno, které vlastní Mutex, zodpovědné za jeho uvolnění. V případě semaforů se však tato podmínka nevyžaduje. Jakékoliv jiné vlákno může signalizovat uvolnění semaforu pomocí s m p s (function.e_ot)

  • Další rozdíl, který by byl pro vývojáře důležitý, je, že semafory jsou systémově široké a zůstávají ve formě souborů na souborovém systému, pokud není jinak vyčištěno. Mutex je procesově dostupný a po ukončení procesu se automaticky vyčistí.

  • Povaha semaforů umožňuje jejich použití při synchronizaci souvisejících a nesouvisejících procesů, jakož i mezi vlákny. Mutex lze použít pouze při synchronizaci mezi vlákny a maximálně mezi souvisejícími procesy (implementace pthread nejnovějšího jádra přichází s funkcí, která umožňuje použití Mutexu mezi souvisejícím procesem).
  • Podle dokumentace jádra je Mutex ve srovnání se semafory lehčí. To znamená, že program s použitím semaforu má vyšší paměťovou stopu ve srovnání s programem, který má Mutex.
  • Z pohledu použití má Mutex ve srovnání se semafory jednodušší sémantiku.
35
Varun Chhangani

Na teoretické úrovni se neliší sémanticky. Mutex můžete implementovat pomocí semaforů nebo naopak (viz příklad zde ). V praxi je implementace odlišná a nabízejí poněkud odlišné služby.

Praktický rozdíl (pokud jde o systémové služby, které je obklopují) spočívá v tom, že implementace mutexu je zaměřena na to, aby byl lehčí synchronizační mechanismus. V Oracle-mluvit, mutexes je známý jak latches a semafory jsou známé jako čeká .

Na nejnižší úrovni používají nějaký atomový mechanismus { test and set . To přečte aktuální hodnotu místa v paměti, spočítá nějaký druh podmíněné a zapíše hodnotu v daném místě do jedné instrukce, kterou nelze přerušit . To znamená, že můžete získat mutex a otestovat, zda ho někdo jiný nemá před vámi.

Typická implementace mutex má proces nebo vlákno provádějící instrukci test-and-set a hodnotící, zda něco jiného nastavilo mutex. Klíčovým bodem je, že neexistuje interakce s plánovačem , takže nemáme žádnou představu (a nezajímá nás), kdo nastavil zámek. Pak se buď vzdáme našeho časového řezu a pokusíme se jej znovu, když je úkol znovu naplánován nebo provést příkaz { spin-lock . Blokování uzamčení je algoritmus jako:

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.

Když jsme dokončili provádění našeho chráněného kódu (označovaného jako kritická sekce ), nastavíme hodnotu mutex na nulu nebo cokoliv znamená „clear“. Pokud se více úkolů pokouší získat mutex, další úkol, který se stane, že bude naplánován po uvolnění mutexu, získá přístup ke zdroji. Obvykle byste použili mutexy pro řízení synchronizovaného zdroje, kde je exkluzivní přístup nutný pouze pro velmi krátkou dobu, obvykle pro aktualizaci sdílené datové struktury.

Semafor je synchronizovaná datová struktura (obvykle používající mutex), která má počet a některé systémové volání obálky, které komunikují s plánovačem v trochu větší hloubce než knihovny mutex. Semafory se zvyšují a snižují a používají se k úkolům blok , dokud není připraveno něco jiného. Pro jednoduchý příklad viz Producer/Consumer Problem . Semafory jsou inicializovány na určitou hodnotu - binární semafor je jen speciální případ, kdy je semafor inicializován na 1. Vysílání do semaforu má za následek probuzení čekacího procesu.

Základní algoritmus semaforu vypadá takto:

(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.

V případě binárního semaforu je hlavním praktickým rozdílem mezi těmito dvěma vlastnostmi systémová služba obklopující aktuální datovou strukturu.

EDIT: Jak Evan správně poukázal, spinlocks zpomalí jednoprocesorový stroj. Spinlock by jste používali pouze na víceprocesorovém boxu, protože proces, ve kterém je mutex spuštěn, nebude v jednom procesoru nikdy resetován, když je spuštěn jiný úkol. Spinlocks jsou užitečné pouze pro víceprocesorové architektury.

I když jsou mutex & semafory používány jako synchronizační primitivy, je mezi nimi velký rozdíl. V případě mutexu jej může odemknout pouze vlákno, které uzamklo nebo získalo mutex. V případě semaforu může být vlákno čekající na semafor signalizováno jiným vláknem. Některé operační systémy podporují použití mutex & semaforů mezi procesy. Používání se obvykle vytváří ve sdílené paměti.

18
Praveen_Shukla

Mutex: Předpokládejme, že máme kritický průřezový závit T1, který chce k němu přistupovat, a pak následuje níže uvedené kroky. T1:

  1. Zámek
  2. Použijte kritickou sekci
  3. Odemknout

Binární semafor: Pracuje na základě signalizačního čekání a signálu. wait (s) pokles hodnoty "s" o jednu hodnotu "s" je inicializována hodnotou "1", signál (y) zvyšuje hodnotu "s" o jednu hodnotu. je-li hodnota "s" 1, znamená to, že nikdo nepoužívá kritickou sekci, když je hodnota 0, používá se kritická sekce. Předpokládejme, že vlákno T2 používá kritickou sekci a následuje níže uvedené kroky. T2:

  1. wait (s) // zpočátku hodnota s je jedna po zavolání počkat je hodnota snížena o jednu, tj. 0
  2. Použijte kritickou sekci
  3. signál (s) // je nyní hodnota s zvýšena a stane se 1

Hlavní rozdíl mezi mutexem a binárním semaforem je v Mutextu, pokud vlákno uzamkne kritickou sekci, pak musí odemknout kritickou sekci, kterou ji nelze odemknout, ale v případě binárního semaforu, pokud jeden podproces zablokuje kritickou sekci pomocí funkce wait (s), pak hodnota s stane se “0” a nikdo nemůže přistupovat k tomu dokud hodnota “s” stane se 1 ale předpokládat nějaké jiné vlákno volá signál (s) pak hodnota “s” stát se 1 a to dovolí jinou funkci používat kritickou sekci. proto v binárním semaforu vlákno nemá vlastnictví.

11
Sumit Naik

Zřejmě použijete mutex k uzamčení dat v jednom vlákně, které jsou současně zpřístupněny jiným vláknem. Předpokládejme, že jste právě zvolili lock() a v procesu přístupu k datům. To znamená, že neočekáváte, že jiné vlákno (nebo jiná instance stejného kódu vlákna) bude mít přístup ke stejným datům uzamčeným stejným mutexem. To znamená, že pokud se jedná o stejný kód podprocesu, který se spouští na jiné instanci podprocesu, narazí na zámek a potom lock() by tam měl blokovat tok řízení. To platí pro podproces, který používá jiný kód vlákna, který také přistupuje ke stejným datům a který je také uzamčen stejným mutexem. V tomto případě jste stále v procesu přístupu k datům a můžete si vzít, řekněme, dalších 15 sekund k dosažení odemknutí mutexu (takže ostatní vlákno, které je blokováno v mutex locku, by odblokovalo a umožnilo by ovládání přístup k datům). Myslíte si, za každou cenu ještě další vlákno jen odemknout stejné mutex, a zase, aby vlákno, které je již čeká (blokování) v zámku mutex odblokovat a přístup k datům? Doufám, že máš to, co tady říkám? Jak je dohodnuto na univerzální definici !,

  • s „mutexem“ se to nemůže stát. Žádné jiné vlákno nemůže odemknout zámek ve vašem vlákně
  • s „binárním semaforem“ se to může stát. Jakýkoli jiný podproces může odemknout zámek v podprocesu

Pokud tedy používáte binární semafor místo mutexu, měli byste být velmi opatrní při „zamykání“ zámků a odemykání. Myslím, že každý kontrolní tok, který zasáhne každý zámek, by měl odemknout volání, také by neměl být žádný „první odemknutí“, spíše by měl být vždy „první zámek“.

10
paxi

Mutex se používá pro "blokovací mechanismy". jeden proces najednou může používat sdílený zdroj

zatímco

Semafory jsou používány pro "Signalizační mechanismy" jako "Jsem hotový, nyní mohu pokračovat"

10
Jamshad Ahmad

V systému Windows existují dva rozdíly mezi mutexy a binárními semafory:

  1. Mutex může být uvolněn pouze vláknem, které je vlastníkem, tj. Vláknem, které se dříve nazývalo funkcí Wait (nebo které převzalo vlastnictví při jeho vytváření). Semafor může být uvolněn libovolným vláknem.

  2. Vlákno může opakovaně volat funkci čekání na mutexu bez blokování. Pokud však volání funkce čekání dvakrát na binární semafor bez uvolnění semafor mezi, podproces bude blokovat.

10
Rich

Mýtus:

Několik článků říká, že "binární semafor a mutex jsou stejné" nebo "Semafor s hodnotou 1 je mutex", ale základní rozdíl je Mutex může být uvolněn pouze vláknem, které ho získalo, zatímco můžete signalizovat semafor z jakéhokoliv jiného vlákna

Klíčové body:

• Vlákno může získat více než jeden zámek (Mutex).

• Mutex může být uzamčen více než jednou pouze tehdy, pokud jeho rekurzivní mutex, zde zámek a odemknutí pro mutex, by měl být stejný.

• Pokud vlákno, které již uzamklo mutex, se znovu pokusí uzamknout mutex, vstoupí do čekací listiny tohoto mutexu, což má za následek zablokování.

• Binární semafor a mutex jsou podobné, ale ne stejné.

• Mutex je nákladný provoz díky ochranným protokolům, které jsou s ním spojeny.

• Hlavním cílem mutexu je dosažení atomového přístupu nebo uzamčení zdroje

9
Saurabh Sinha

A Mutex řídí přístup k jedinému sdílenému prostředku. Poskytuje operace gain () přístup k tomuto zdroji a release () to when done.

A Semafor kontroluje přístup ke sdílenému fondu zdrojů. Poskytuje operace Wait () , dokud není k dispozici jeden ze zdrojů ve fondu, a Signal () když je dán zpět do fondu.

Když je počet prostředků, které Semafor chrání, větší než 1, nazývá se Počítání semaforu . Když ovládá jeden zdroj, nazývá se booleovský semafor . Booleovský semafor je ekvivalentní mutexu.

Semafor je tedy abstrakce vyšší úrovně než Mutex. Mutex lze implementovat pomocí Semaforu, ale ne naopak.

8
Charan

Upravená otázka je - Jaký je rozdíl mezi mutexem a "binárním" semaforem v "Linuxu"?

Ans: Následují rozdíly - i) Rozsah - Rozsah mutexu je v rámci adresního prostoru procesu, který jej vytvořil a používá se pro synchronizaci vláken. Zatímco semafor může být používán napříč procesním prostorem, a proto může být použit pro synchronizaci mezi procesy.

ii) Mutex je lehký a rychlejší než semafor. Futex je ještě rychlejší.

iii) Mutex může být získán stejným vláknem úspěšně několikrát za podmínky, že by ho měl uvolnit stejný početkrát. Ostatní vlákno, které se snaží získat, bude blokovat. Vzhledem k tomu, že v případě semaforu se tento proces snaží znovu získat, blokuje, protože je možné jej získat pouze jednou.

6
Mickey

Mutex pracuje na blokování kritické oblasti, ale Semafor pracuje na počtu.

6
Askkan

Rozdíl mezi binárním semaforem a mutexem: VLASTNICTVÍ: Semafory mohou být signalizovány (zaúčtovány) i od současného vlastníka. To znamená, že můžete jednoduše psát z jakéhokoli jiného vlákna, i když nejste vlastníkem.

Semafor je veřejný majetek, který může být jednoduše odeslán vláknem, které není vlastníkem. Označte tento rozdíl v BOLD dopisech, to znamená hodně.

5
buddingspacer

http://www.geeksforgeeks.org/archives/9102 pojednává podrobně.

Mutex je blokovací mechanismus používaný k synchronizaci přístupu ke zdroji. Semaphore je signalizační mechanismus.

Záleží na programátorovi, zda chce místo mutexu použít binární semafor.

5
user1852497

V systému Windows je rozdíl stejný jako níže. MUTEX: proces, který úspěšně provede wait má provést signál a naopak. BINARY SEMAPHORES: Různé procesy mohou provádět wait nebo signal operation na semaforu.

4
ajay bidari

Kromě toho, že mutexy mají vlastníka, mohou být dva objekty optimalizovány pro různé použití. Mutexy jsou navrženy tak, aby byly drženy pouze na krátkou dobu; porušení tohoto pravidla může způsobit špatný výkon a nekalé plánování. Například běh podprocesu může být povoleno získat mutex, i když je na něm již zablokováno jiné vlákno. Semafory mohou poskytovat větší spravedlnost nebo spravedlnost může být vynucena používat několik proměnných podmínky.

4
jilles

Tento koncept mi ​​byl jasný poté, co jsem přešel na pracovní místa. Ale byly nějaké přetrvávající otázky. Tak jsem napsal tento malý kousek kódu.

Když se pokusíme dát semafor, aniž bychom to vzali, prochází to. Ale když se pokusíte dát mutex, aniž by to, to selže. Testoval jsem to na platformě Windows. Povolit USE_MUTEX spustit stejný kód pomocí 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

Zatímco binární semafor může být používán jako mutex, mutex je specifičtější případ použití, v tom, že pouze proces, který uzamkl mutex, má odemknout. Toto omezení vlastnictví umožňuje poskytnout ochranu před:

  • Náhodné uvolnění
  • Rekurzivní zablokování
  • Úloha Smrt Deadlock

Tato omezení nejsou vždy přítomna, protože snižují rychlost. Během vývoje kódu můžete tyto kontroly dočasně povolit.

např. můžete aktivovat atribut Kontrola chyb ve vašem mutexu. Chyba při kontrole mutexes return EDEADLK pokud se pokusíte dvakrát zamknout stejný soubor a EPERM pokud odemknete mutex, který není váš.

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

Po inicializaci můžeme tyto kontroly umístit do našeho kódu takto:

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

Mutex se používá k ochraně citlivého kódu a dat, semafor se používá k synchronizaci.Můžete také mít praktické použití s ​​ochranou citlivého kódu, ale může existovat riziko, že uvolnění ochrany jiným vláknem operací V.So Hlavní rozdíl mezi bi-semaforem a mutexem je vlastnictvím.Například WC, Mutex je takový, že člověk může vstoupit na toaletu a zamknout dveře, nikdo jiný nemůže vstoupit, dokud se člověk nedostane ven, bi-semafor je takový, že člověk může vstoupit WC a zamknout dveře, ale někdo jiný by mohl vstoupit tím, že požádá správce, aby otevřel dveře, je to směšné.

2
mannnnerd

Mutexes mají vlastnictví, na rozdíl od semaforů. Ačkoliv libovolné vlákno v rámci mutexu může získat odemčený mutex a uzamknout přístup ke stejné kritické části kódu, pouze vlákno, které uzamklo mutex by mělo odemknout .

1
laksbv

Mutex a binární semafor jsou oba stejného použití, ale ve skutečnosti jsou odlišné.

V případě mutexu jej může odemknout pouze vlákno, které je uzamčeno. Pokud přijde nějaká jiná nit, zamkne se, bude čekat.

V případě semafonu to tak není. Semafor není vázán na konkrétní ID vlákna.

1
Neeraj Sh

Odpověď může záviset na cílovém OS. Například alespoň jedna implementace RTOS, kterou znám, umožní vícenásobné sekvenční operace "get" proti jednomu operačnímu systému mutex, pokud jsou všechny ve stejném kontextu podprocesu. Mnohonásobné získání musí být nahrazeno stejným počtem puts než jiný vlákno bude moci dostat mutex. Toto se liší od binárních semaforů, pro které je současně povoleno pouze jediné získání, bez ohledu na kontext podprocesů.

Myšlenkou tohoto typu mutex je, že objekt chráníte pouze tím, že umožníte jednotlivým kontextům měnit data najednou. I když vlákno dostane mutex a pak zavolá funkci, která objekt dále modifikuje (a dostane/dá chránič mutex kolem svých vlastních operací), operace by měly být stále bezpečné, protože se dějí pod jedním vláknem.

{
    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.
}

Samozřejmě, když používáte tuto funkci, musíte si být jisti, že všechny přístupy v rámci jednoho vlákna jsou opravdu bezpečné!

Nejsem si jistý, jak je tento přístup společný, nebo zda platí mimo systémy, se kterými jsem seznámen. Příklad tohoto typu mutex naleznete v tématu ThreadX RTOS.

1
Casey Barker

Jak se zde zmínilo mnoho lidí, mutex se používá k ochraně kritického kusu kódu (kritická sekce AKA.) Získáte mutex (lock), zadáte kritickou sekci a uvolníte mutex (unlock) vše ve stejném vlákně .

Při použití semaforu můžete provést podproces čekání na semafor (řekněme vlákno A), dokud jiný podproces (řekněme vlákno B) nedokončí jakýkoli úkol a potom nastaví semafor pro vlákno A, aby zastavil čekání a pokračoval ve svém úkolu.

1
Dom045

"binární semafor" je programovací jazyk, který obchází použití "semaforu" jako "mutex". Zřejmě existují dva velmi velké rozdíly:

  1. Způsob, jakým zavoláte každému z nich.

  2. Maximální délka "identifikátoru".

0
ilias iliadis