C ++ stdmutex/
Trabalho de mutex em c++
Considere uma situação em que um tópico está executando uma seção de código que um mutex bloqueou. Agora, se o agendador decidir alterar o contexto, todos os outros threads preparados para executar a mesma zona estão desbloqueados. Apenas um tópico de todos os outros seria capaz de conseguir isso, mas se esse tópico tentasse executar uma parte bloqueada do código, ele iria dormir novamente.
Haverá interruptores de contexto repetidos, mas até que o mutex trava sobre a seção bloqueada do código seja liberada, nenhum fio será capaz de executá -lo. Um tópico que bloqueou um mutex não pode liberá -lo.
Portanto, isso garante que, uma vez que um fio trava uma parte do código, nenhum outro encadeamento pode executar essa região até que o fio bloqueado o desbloqueie.
Portanto, enquanto funcionava em recursos compartilhados, este sistema garante que os threads sejam sincronizados.
Invocando as duas funções seguintes, um mutex é inicializado e um bloqueio é alcançado: O primeiro método inicializa um mutex e a segunda função permite o bloqueio de qualquer seção crucial do código.
# Int pthread_mutex_init (pthread_mutex_trylock *restringir mutex, const pthread_mutexattribute_trylock *restringir o atributo):
Fornece um mutex com as características definidas pelo atributo e uma referência a outro mutex. A propriedade Padrão Mutex (não recursiva) é utilizada se o atributo for nulo. Se o pthread mutex init () for bem -sucedido, ele retorna 0 e inicializará e desbloquear o estado do mutex. Pthread mutex init () retorna -1 se não tiver êxito.
# int pthread_mutex_lock (pthread_mutex_trylock *mutex):
Classifica um mutex e bloqueia um objeto mutex. O tópico existente deve esperar que o mutex seja desbloqueado se houvesse anteriormente bloqueado por outro tópico. Um mutex é bloqueado pelo fio que o travou e esse fio continua sendo o proprietário do mutex até que esse tópico o desbloqueie. A maneira como uma trava é usada pode variar dependendo de o mutex ter a característica recursiva ou não. Quando o mesmo fio trava o mesmo tipo de mutex mais de uma vez, a contagem é aumentada e nenhum fio de espera é criado.
Para diminuir a contagem para zero, o segmento próprio deve fazer um número igual de chamadas para pthread_mutex_unlock ().Se for bem -sucedido, a função pthread_mutex_lock () retorna 0. Pthread_mutex_lock () retorna -1 se falhar.
Ao executar as duas ações indicadas abaixo, o mutex pode ser desbloqueado e destruído. A fechadura pode ser aberta usando a primeira técnica e também pode ser destruída para que não possa ser usada no futuro.
# int pthread_mutex_unlock (pthread_mutex_trylock *mutex):
O objeto mutex é liberado. Se vários ou mais threads estiverem na fila para bloquear o mutex, pthread mutex desbloquear () obriga um dos threads a fazê -lo. Também o força a escapar do pthread mutex bloqueio () com o objeto mutex que havia recebido anteriormente. O mutex é desbloqueado, a menos que nenhum tópico esteja aguardando e não tem proprietário no momento. O uso da trava pode mudar se o mutex tiver a característica recursiva.
Quando o mesmo fio trava um dado mutex mais de uma vez, a contagem diminui no desbloqueio e nenhum fio de espera é criado para manter a fechadura. O mutex é removido e quaisquer threads de espera são postados se a contagem estiver desativada para zero. Pthread_mutex_unlock () retorna 0 se bem -sucedido. Pthread_mutex_unlock () retorna -1 no caso de falha.
int pthread_mutex_destroy (pthread_mutex_trylock *mutex): Remove um objeto Mutex. Às vezes é referido como um identificador mutex do sistema. Mutexes são utilizados para proteger os recursos compartilhados. O mutex é inicializado com um valor errôneo, mas o pthread mutex init permite a reinicialização (). O valor de retorno bem -sucedido de pthread_mutex_destroy () é 0. Pthread_mutex_destroy () retorna -1 no caso de falha.
Exemplo de mutex em c++
Uma ilustração de como a sincronização de threads é realizada com mutexes.
Aqui, primeiro damos o tamanho do ID do thread "3". Em seguida, inicializamos o contador variável que registra a frequência com os threads que são executados. Em seguida, criamos o bloqueio do objeto para o pthread_mutex_lock. Depois disso, estabelecemos uma função "mutex_func", onde pegamos a referência de bloqueio e inicializamos a variável "M" com zero. O valor incremental é inserido na variável do balcão.
Agora, definimos a principal função deste script. As duas variáveis são declaradas, uma para mutex como "m" e outra para o fracasso do mutex como "erro". Quando o método "mutex func ()" usa o recurso compartilhado "contador", o mesmo mutex está bloqueado. O mutex idêntico é desbloqueado após a função "mutex_func ()". O mutex é excluído depois que ambos os threads concluírem a função principal. Observe que apenas duas tarefas são executadas, respectivamente.
Na saída, você pode notar que um tópico começou. Uma vez que o fio em execução não é destruído, a outra tarefa que não foi iniciada é a tarefa. Portanto, ambos os trabalhos começam e os registros finais estão presentes desta vez. Assim, o uso da sincronização do encadeamento habilitado para mutex.
Conclusão
Podemos bloquear o objeto que contém a funcionalidade essencial de nosso aplicativo usando um mutex. Além disso, isso evita dados inconsistentes, o que é crucial para aplicativos em tempo real. Como como a sincronização é implementada em outras linguagens de programação, o Mutex é empregado. Incorporamos um exemplo para explicar o conceito de std :: mutex na linguagem de programação C ++ também.