it-swarm-pt.tech

Diferença entre o semáforo binário e o mutex

Existe alguma diferença entre um semáforo binário e um mutex ou eles são essencialmente os mesmos?

741
Nitin

Eles sãoNÃOa mesma coisa. Eles são usados ​​para diferentes propósitos!
Embora ambos os tipos de semáforos tenham um estado completo/vazio e usem a mesma API, seu uso é muito diferente.

Semáforos de Exclusão Mútua
Os semáforos de exclusão mútua são usados ​​para proteger recursos compartilhados (estrutura de dados, arquivo, etc.).

Um semáforo Mutex é "possuído" pela tarefa que o executa. Se a tarefa B tenta semitivar um mutex atualmente mantido pela tarefa A, a chamada da tarefa B retornará um erro e falhará.

Mutexes sempre usam a seguinte seqüência:

 - SemTake 
 - Seção Crítica 
 - SemGive

Aqui está um exemplo simples:

 Enfie um Fio B 
 Leve os dados de acesso do Mutex 
 
 ... Leve o Mutex <== Bloqueio 
 ... 
 Dar dados de acesso a Mutex <== Desbloqueia 
 ... 
 Dê a Mutex 

Semaphore binário
Semaphore Binary aborda uma questão totalmente diferente:

  • A tarefa B está pendente esperando que algo aconteça (um sensor sendo acionado, por exemplo).
  • Viagens de sensor e uma rotina de serviço de interrupção são executadas. Precisa notificar uma tarefa da viagem.
  • A tarefa B deve executar e tomar as ações apropriadas para a viagem do sensor. Então volte para a espera.

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

Note que com um semáforo binário, está OK para B pegar o semáforo e A para dar.
Novamente, um semáforo binário NÃO está protegendo um recurso de acesso. O ato de dar e pegar um semáforo é fundamentalmente desacoplado.
Normalmente, faz pouco sentido para a mesma tarefa dar uma olhada no mesmo semáforo binário.

635
Benoit

O exemplo do banheiro é uma analogia agradável:

Mutex:

É uma chave para um banheiro. Uma pessoa pode ter a chave - ocupar o banheiro - no momento. Quando terminada, a pessoa dá (libera) a chave para a próxima pessoa na fila.

Oficialmente: "Mutexes são normalmente usados ​​para serializar o acesso a uma seção de código reentrante que não pode ser executada simultaneamente por mais de um thread. Um objeto mutex permite apenas um thread em uma seção controlada, forçando outros threads que tentam obter acesso a essa seção para esperar até que o primeiro segmento tenha saído dessa seção. " Ref: Biblioteca de Programadores Symbian

(Um mutex é realmente um semáforo com valor 1.)

Semáforo:

É o número de chaves de sanita idênticas gratuitas. Exemplo, digamos que temos quatro banheiros com fechaduras e chaves idênticas. A contagem do semáforo - a contagem de chaves - é definida como 4 no início (todos os quatro banheiros estão livres), então o valor da contagem é diminuído conforme as pessoas estão chegando. Se todos os banheiros estão cheios, ou seja. não há chaves livres, a contagem do semáforo é 0. Agora, quando eq. uma pessoa sai do banheiro, o semáforo é aumentado para 1 (uma chave livre) e dado à próxima pessoa na fila.

Oficialmente: "Um semáforo restringe o número de usuários simultâneos de um recurso compartilhado até um número máximo. As threads podem solicitar acesso ao recurso (diminuindo o semáforo) e podem sinalizar que terminaram de usar o recurso (incrementando o semáforo). " Ref: Biblioteca de Programadores Symbian

416
dlinsin

Mutex pode ser liberado somente por thread que o adquiriu, enquanto você pode sinalizar um semáforo de qualquer outro thread (ou processo), então os semáforos são mais adequados para alguns problemas de sincronização como produtor-consumidor.

No Windows, os semáforos binários são mais como objetos de evento que mutexes.

411
Mladen Janković

Nice artigos sobre o tema:

Da parte 2:

O mutex é semelhante aos princípios do semáforo binário com uma diferença significativa: o princípio da propriedade. A propriedade é o conceito simples de que, quando uma tarefa bloqueia (adquire) um mutex, somente ele pode ser desbloqueado (liberado). Se uma tarefa tentar desbloquear um mutex que não tenha sido bloqueado (não é por isso), será encontrada uma condição de erro e, mais importante, o mutex não será desbloqueado. Se o objeto de exclusão mútua não tiver propriedade, então, irrelevante do que é chamado, não é um mutex.

139
teki

Como nenhuma das respostas acima esclarece a confusão, aqui está uma que esclareceu minha confusão.

Estritamente falando, um mutex é um mecanismo de bloqueio usado para sincronizar o acesso a um recurso. Apenas uma tarefa (pode ser um encadeamento ou processo baseado na abstração do sistema operacional) pode adquirir o mutex. Isso significa que haverá propriedade associada ao mutex e somente o proprietário poderá liberar o bloqueio (mutex).

Semaphore é mecanismo de sinalização (“Eu estou pronto, você pode continuar” tipo de sinal). Por exemplo, se você estiver ouvindo músicas (assuma como uma tarefa) em seu celular e ao mesmo tempo seu amigo ligou para você, será acionada uma interrupção na qual uma rotina de serviço de interrupção (ISR) sinalizará a tarefa de processamento de chamadas para ativação .

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

92
Hemant

Sua semântica de sincronização é muito diferente:

  • mutexes permitem a serialização do acesso a um determinado recurso, ou seja, vários threads aguardam um bloqueio, um de cada vez e, como dito anteriormente, o thread owns the lock até que seja feito: only this thread particular pode desbloqueá-lo.
  • um semáforo binário é um contador com valor 0 e 1: uma tarefa bloqueando nele até any task faz um sem_post. O semáforo anuncia que um recurso está disponível e fornece o mecanismo para aguardar até que seja sinalizado como disponível.

Como tal, pode-se ver um mutex como um token passado de tarefa para tarefas e um semáforo como sinal vermelho de tráfego (é sinaliza alguém que pode continuar).

37
ppi
  • A Mutex , por definição, é usado para serializar o acesso a uma seção do código reentrante que não pode ser executada simultaneamente por mais de um encadeamento.

  • A Semaphore , por definição, restringe o número de usuários simultâneos de um recurso compartilhado até um número máximo

  • Um semáforo pode ser um Mutex, mas um mutex nunca pode ser semáforo. Isso significa simplesmente que um semáforo binário pode ser usado como Mutex, mas um Mutex nunca pode exibir a funcionalidade do semáforo.

  • Ambos os semáforos e mutex (pelo menos o kernel mais recente) são de natureza não-recursiva.
  • Ninguém possui semáforos, enquanto a Mutex é de propriedade e o proprietário é responsável por eles. Essa é uma distinção importante de uma perspectiva de depuração.
  • No caso do Mutex, o thread que possui o Mutex é responsável por liberá-lo. No entanto, no caso de semáforos, essa condição não é necessária. Qualquer outro segmento pode sinalizar para liberar o semáforo usando o s m p s (function.e_ot)

  • Outra diferença que importaria para os desenvolvedores é que os semáforos são de todo o sistema e permanecem na forma de arquivos no sistema de arquivos, a menos que sejam limpos de outra forma. As mutex são processadas em todo o processo e são limpas automaticamente quando um processo é encerrado.

  • A natureza dos semáforos torna possível usá-los na sincronização de processos relacionados e não relacionados, bem como entre threads. O mutex pode ser usado apenas na sincronização entre encadeamentos e, no máximo, entre processos relacionados (a implementação pthread do kernel mais recente vem com um recurso que permite que o Mutex seja usado entre processos relacionados).
  • De acordo com a documentação do kernel, o Mutex é mais claro quando comparado aos semáforos. O que isto significa é que um programa com uso de semáforo tem uma pegada de memória maior quando comparado a um programa tendo Mutex.
  • De uma perspectiva de uso, o Mutex possui uma semântica mais simples quando comparado aos semáforos.
35
Varun Chhangani

Em um nível teórico, eles não são diferentes semanticamente. Você pode implementar um mutex usando semáforos ou vice-versa (veja aqui para um exemplo). Na prática, a implementação é diferente e eles oferecem serviços ligeiramente diferentes.

A diferença prática (em termos dos serviços do sistema em torno deles) é que a implementação de um mutex tem como objetivo ser um mecanismo de sincronização mais leve. No Oracle-speak, os mutexes são conhecidos como latches e os semáforos são conhecidos como waits .

No nível mais baixo, eles usam algum tipo de mecanismo atomic test e set . Isso lê o valor atual de um local de memória, calcula algum tipo de condicional e grava um valor naquele local em uma única instrução que não pode ser interrompida . Isso significa que você pode adquirir um mutex e testar para ver se alguém já o fez antes de você.

Uma implementação típica de mutex tem um processo ou thread executando a instrução test-and-set e avaliando se alguma outra coisa configurou o mutex. Um ponto chave aqui é que não há interação com o scheduler , então não temos idéia (e não nos importamos) quem definiu o bloqueio. Então, nós desistimos da nossa fatia de tempo e tentamos novamente quando a tarefa é reordenada ou executamos um spin-lock . Um bloqueio de giro é um algoritmo como:

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 terminamos de executar nosso código protegido (conhecido como seção crítica ), apenas definimos o valor do mutex como zero ou o que quer que seja 'claro'. Se várias tarefas estiverem tentando adquirir o mutex, a próxima tarefa que for agendada após o lançamento do mutex terá acesso ao recurso. Normalmente, você usa mutexes para controlar um recurso sincronizado em que o acesso exclusivo é necessário apenas por curtos períodos de tempo, normalmente para atualizar a estrutura de dados compartilhada.

Um semáforo é uma estrutura de dados sincronizada (geralmente usando um mutex) que possui uma contagem e alguns wrappers de chamada de sistema que interagem com o planejador em um pouco mais de profundidade do que as bibliotecas mutex fariam. Os semáforos são incrementados e decrementados e usados ​​para block tasks até que algo esteja pronto. Veja Producer/Consumer Problem para um exemplo simples disso. Os semáforos são inicializados com algum valor - um semáforo binário é apenas um caso especial em que o semáforo é inicializado como 1. A postagem em um semáforo tem o efeito de ativar um processo de espera.

Um algoritmo de semáforo básico se parece com:

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

No caso de um semáforo binário, a principal diferença prática entre os dois é a natureza dos serviços do sistema em torno da estrutura de dados real.

EDIT: Como evan apontou corretamente, spinlocks irá abrandar uma máquina de processador único. Você só usaria um spinlock em uma caixa de multiprocessador porque, em um único processador, o processo que mantém o mutex nunca o redefinirá enquanto outra tarefa estiver em execução. Os Spinlocks são úteis apenas em arquiteturas de multiprocessadores.

21
ConcernedOfTunbridgeWells

Embora o mutex e os semáforos sejam usados ​​como primitivos de sincronização, existe uma grande diferença entre eles. No caso de mutex, apenas o thread que bloqueou ou adquiriu o mutex pode desbloqueá-lo. No caso de um semáforo, um thread aguardando em um semáforo pode ser sinalizado por um thread diferente. Alguns sistemas operacionais suportam o uso de mutex e semáforos entre processos. Normalmente, o uso é criado na memória compartilhada.

18
Praveen_Shukla

Mutex: suponha que temos um segmento de seção crítico que T1 deseja acessá-lo, depois segue os passos abaixo. T1:

  1. Bloqueio
  2. Use a Seção Crítica
  3. Desbloquear

Semáforo binário: Funciona com base na sinalização de espera e sinal. wait (s) diminui o valor "s" em um valor normalmente "s" é inicializado com o valor "1", o (s) sinal (es) aumenta o valor "s" em um. se o valor "s" for 1 significa que ninguém está usando uma seção crítica, quando o valor for 0 significa que a seção crítica está em uso. suponha que o thread T2 esteja usando uma seção crítica e siga as etapas abaixo. T2:

  1. wait (s) // inicialmente s valor é um depois de chamar wait é o valor diminuído por um, ou seja, 0
  2. Use seção crítica
  3. sinal (es) // agora o valor é aumentado e ele se torna 1

A principal diferença entre Mutex e Binary semaphore é em Mutext se thread bloquear a seção crítica, então ele tem que desbloquear a seção crítica nenhum outro thread pode desbloqueá-lo, mas no caso de semaphore binário se um thread bloqueia seção crítica usando função wait (s), em seguida, valor de s torna-se "0" e ninguém pode acessá-lo até que o valor de "s" se torne 1, mas suponha que algum outro sinal de chamada de thread, então o valor de "s" se torne 1 e permita que outra função use a seção crítica. daqui no fio de semáforo binário não tem propriedade.

11
Sumit Naik

Você obviamente usa mutex para bloquear um dado em um thread, sendo acessado por outro thread ao mesmo tempo. Suponha que você acabou de chamar lock() e no processo de acessar dados. Isso significa que você não espera que nenhum outro segmento (ou outra instância do mesmo código de thread) acesse os mesmos dados bloqueados pelo mesmo mutex. Ou seja, se for o mesmo thread-code sendo executado em uma instância de thread diferente, atinge o bloqueio, então a lock() deve bloquear o fluxo de controle lá. Isso se aplica a um thread que usa um código de thread diferente, que também está acessando os mesmos dados e que também está bloqueado pelo mesmo mutex. Neste caso, você ainda está no processo de acessar os dados e pode levar, digamos, outros 15 segundos para alcançar o desbloqueio mutex (para que o outro thread que está sendo bloqueado no bloqueio de mutex desbloqueie e permita que o controle acessar os dados). Você a qualquer custo permite ainda outro segmento para apenas desbloquear o mesmo mutex, e por sua vez, permitir que o segmento que já está aguardando (bloqueio) no bloqueio mutex para desbloquear e acessar os dados? Espero que você tenha o que estou dizendo aqui? De acordo com a definição universal acordada!

  • com "mutex" isso não pode acontecer. Nenhum outro segmento pode desbloquear o bloqueio em seu segmento
  • com “binário-semáforo” isso pode acontecer. Qualquer outro segmento pode desbloquear o bloqueio em seu segmento

Então, se você é muito particular sobre o uso de binário-semáforo em vez de mutex, então você deve ter muito cuidado em “escopo” dos bloqueios e desbloqueios. Quero dizer que todo fluxo de controle que atinge cada bloqueio deve atingir uma chamada de desbloqueio, e também não deve haver nenhum "primeiro desbloqueio", mas deve ser sempre "primeiro bloqueio".

10
paxi

Mutex são usados ​​para "Mecanismos de bloqueio". um processo de cada vez pode usar um recurso compartilhado

enquanto que

Semáforos são usados ​​para "Mecanismos de Sinalização" como "Eu estou pronto, agora posso continuar"

10
Jamshad Ahmad

No Windows, existem duas diferenças entre mutexes e semáforos binários:

  1. Um mutex só pode ser liberado pelo encadeamento que possui a propriedade, ou seja, o encadeamento que anteriormente chamava a função Wait (ou que assumiu a propriedade ao criá-lo). Um semáforo pode ser liberado por qualquer thread.

  2. Um thread pode chamar uma função de espera repetidamente em um mutex sem bloqueio. No entanto, se você chamar uma função wait duas vezes em um semáforo binário sem liberar o semáforo no meio, o thread será bloqueado.

10
Rich

Mito:

Um par de artigos diz que "semaphore e mutex binários são os mesmos" ou "Semaphore com valor 1 é mutex" mas a diferença básica é Mutex pode ser liberada apenas por thread que o adquiriu, enquanto você pode sinalizar semáforo de qualquer outro thread

Pontos chave:

• Um thread pode adquirir mais de um bloqueio (mutex).

• Um mutex pode ser bloqueado mais de uma vez somente se for um mutex recursivo, aqui bloquear e desbloquear para mutex deve ser o mesmo

• Se um encadeamento que já tiver bloqueado um mutex, tentar bloquear o mutex novamente, ele entrará na lista de espera desse mutex, o que resulta em deadlock.

• Semáforo binário e mutex são semelhantes, mas não iguais.

• O Mutex é uma operação dispendiosa devido aos protocolos de proteção associados a ele.

• Principal objetivo do mutex é obter acesso atômico ou bloquear recursos

9
Saurabh Sinha

A Mutex controla o acesso a um único recurso compartilhado. Ele fornece operações para acquire () acesso a esse recurso e release () quando concluído.

A Semaphore controla o acesso a um conjunto compartilhado de recursos. Ele fornece operações para Wait () até que um dos recursos no pool se torne disponível e Signal () quando é devolvido ao pool.

Quando o número de recursos que um Semaphore protege é maior que 1, ele é chamado de Semáforo Contador . Quando ele controla um recurso, ele é chamado de Semaphore booleano . Um semáforo booleano é equivalente a um mutex.

Assim, um Semaphore é uma abstração de nível superior ao Mutex. Um Mutex pode ser implementado usando um Semaphore, mas não o contrário.

8
Charan

Pergunta modificada é - Qual é a diferença entre um mutex e um semáforo "binário" em "Linux"?

Resposta: As seguintes são as diferenças - i) Escopo - O escopo do mutex está dentro de um espaço de endereço de processo que o criou e é usado para sincronização de encadeamentos. Considerando que o semáforo pode ser usado em todo o espaço do processo e, portanto, pode ser usado para sincronização entre processos.

ii) Mutex é leve e mais rápido que o semáforo. O Futex é ainda mais rápido.

iii) Mutex pode ser adquirido pelo mesmo thread com sucesso várias vezes com a condição de que ele deve liberar o mesmo número de vezes. Outro segmento tentando adquirir irá bloquear. Considerando que no caso do semáforo se o mesmo processo tenta adquiri-lo novamente bloqueia como pode ser adquirido apenas uma vez.

6
Mickey

Mutex trabalho no bloqueio da região crítica, mas o trabalho Semaphore na contagem.

6
Askkan

Diferença entre semáforo binário e mutex: PROPRIEDADE: Semáforos podem ser sinalizados (postados) até mesmo de um proprietário não atual. Isso significa que você pode simplesmente postar de qualquer outro tópico, embora você não seja o proprietário.

Semaphore é uma propriedade pública em processo. Ela pode ser simplesmente postada por um thread de não proprietário. Por favor, marque essa diferença em letras negrito, isso significa muito.

5
buddingspacer

http://www.geeksforgeeks.org/archives/9102 discute em detalhes.

Mutex é o mecanismo de bloqueio usado para sincronizar o acesso a um recurso. Semaphore é o mecanismo de sinalização.

Sua até programador se ele/ela quer usar o semáforo binário no lugar de mutex.

5
user1852497

No windows a diferença é como abaixo. MUTEX: process que executa com sucesso wait tem que executar um signal e vice-versa. SEMAPHORES BINÁRIOS: Processos diferentes podem executar esperar ou sinal operação em um semáforo.

4
ajay bidari

Além do fato de que mutexes têm um proprietário, os dois objetos podem ser otimizados para uso diferente. Mutexes são projetados para serem mantidos apenas por um curto período de tempo; violar isso pode causar um desempenho ruim e um cronograma injusto. Por exemplo, um thread em execução pode ter permissão para adquirir um mutex, mesmo que outro thread já esteja bloqueado nele. Semáforos podem fornecer mais justiça, ou a imparcialidade pode ser forçada usando várias variáveis ​​de condição.

4
jilles

O conceito ficou claro para mim depois de passar por cima dos posts. Mas havia algumas questões persistentes. Então, eu escrevi este pequeno pedaço de código.

Quando tentamos dar um semáforo sem passar, ele passa. Mas, quando você tenta dar um mutex sem tomá-lo, ele falha. Eu testei isso em uma plataforma Windows. Ative o USE_MUTEX para executar o mesmo código usando um 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

Embora um semáforo binário possa ser usado como um mutex, um mutex é um caso de uso mais específico, em que apenas o processo que bloqueia o mutex deve desbloqueá-lo. Essa restrição de propriedade torna possível fornecer proteção contra:

  • Liberação acidental
  • Deadlock Recursivo
  • Tarefa Morte Impasse

Essas restrições nem sempre estão presentes porque degradam a velocidade. Durante o desenvolvimento do seu código, você pode habilitar essas verificações temporariamente.

por exemplo. você pode ativar o atributo de verificação de erros no seu mutex. Erro ao verificar mutexes return EDEADLK se você tentar bloquear o mesmo duas vezes e EPERM se você desbloquear um mutex que não é seu.

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

Uma vez inicializado, podemos colocar essas verificações em nosso código da seguinte forma:

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

Mutex é usado para proteger o código sensível e dados, semáforo é usado para sincronização.Você também pode ter uso prático com proteger o código sensível, mas pode haver um risco que liberar a proteção pelo outro segmento pela operação V.So O principal diferença entre bi-semáforo e mutex é a propriedade.Por exemplo, por banheiro, Mutex é como que se pode entrar no banheiro e trancar a porta, ninguém mais pode entrar até o homem sair, bi-semáforo é como se pode entrar o banheiro e trancar a porta, mas alguém poderia entrar pedindo ao administrador para abrir a porta, é ridículo.

2
mannnnerd

Os mutexes são proprietários, ao contrário dos semáforos. Embora qualquer encadeamento, dentro do escopo de um mutex, possa obter um mutex desbloqueado e bloquear o acesso à mesma seção crítica de código, somente o encadeamento que bloqueou um mutex deve desbloqueá-lo .

1
laksbv

Mutex e binário são ambos do mesmo uso, mas na realidade, eles são diferentes.

No caso de mutex, apenas o thread que o bloqueou pode desbloqueá-lo. Se algum outro segmento vier bloqueá-lo, ele aguardará.

No caso de semaphone, esse não é o caso. O semáforo não está vinculado a um ID de encadeamento específico.

1
Neeraj Sh

A resposta pode depender do sistema operacional de destino. Por exemplo, pelo menos uma implementação RTOS com a qual estou familiarizado permitirá várias operações "get" sequenciais em relação a um único mutex do sistema operacional, desde que elas sejam todas do mesmo contexto de encadeamento. Os múltiplos gets devem ser substituídos por um número igual de puts antes que outro thread possa obter o mutex. Isso difere dos semáforos binários, para os quais apenas um único get é permitido por vez, independentemente dos contextos de thread.

A idéia por trás desse tipo de mutex é que você protege um objeto, permitindo apenas que um único contexto modifique os dados por vez. Mesmo que o thread obtenha o mutex e, em seguida, chame uma função que modifica ainda mais o objeto (e obtém/coloca o mutex protetor em torno de suas próprias operações), as operações ainda devem ser seguras porque todas elas estão acontecendo em um único 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.
}

É claro que, ao usar esse recurso, você deve ter certeza de que todos os acessos em um único thread são seguros!

Não tenho certeza de como essa abordagem é comum ou se ela se aplica fora dos sistemas com os quais estou familiarizado. Para um exemplo desse tipo de mutex, veja o ThreadX RTOS.

1
Casey Barker

Como muitas pessoas aqui mencionaram, um mutex é usado para proteger uma parte crítica do código (seção crítica AKA). Você irá adquirir o mutex (lock), entrar na seção crítica e liberar mutex (unlock) todos no mesmo thread .

Ao usar um semáforo, você pode fazer um thread aguardar em um semáforo (digamos, thread A), até que outro thread (diga thread B) conclua qualquer tarefa e, em seguida, defina o Semaphore para thread A para parar a espera e continuar sua tarefa.

1
Dom045

"binário semáforo" é uma linguagem de programação contornada para usar um "semáforo" como "mutex". Aparentemente, existem duas diferenças muito grandes:

  1. A maneira como você chama cada um deles.

  2. O comprimento máximo do "identificador".

0
ilias iliadis