Trava mutex c ++

Sabe -se que o C ++ é uma das linguagens de programação mais rápidas com bom desempenho, alta precisão e um sistema de gerenciamento de memória adequado. Essa linguagem de programação também suporta a execução simultânea de vários threads com o compartilhamento de vários recursos entre eles. No multithreading, o tópico é apenas para executar a operação de leitura que não faz problemas, pois o tópico não é afetado pelo que os outros threads estão fazendo naquele momento. Mas se esses tópicos tiveram que compartilhar os recursos entre eles, um tópico pode modificar os dados naquele momento, o que torna o problema. Para lidar com esse problema, temos o C ++ "Mutex", que impede o acesso de vários recursos em relação ao nosso código/objeto, fornecendo a sincronização que afirma que o acesso ao objeto/código pode ser fornecido a apenas um thread ao mesmo tempo, para que múltiplos tópicos não possam acessar esse objeto simultaneamente.

Procedimento:

Vamos saber como podemos parar o acesso de vários threads a um objeto em uma única época usando o MUTEX Lock. Falaremos sobre a sintaxe do bloqueio mutex, o que é múltiplo e como podemos lidar com os problemas causados ​​por múltiplos threading usando o bloqueio mutex. Em seguida, vamos dar um exemplo do múltiplo e implementar o bloqueio mutex neles.

Sintaxe:

Se quisermos aprender como podemos implementar o bloqueio mutex para que possamos impedir o acesso de vários threads simultaneamente em relação ao nosso objeto ou código, podemos usar a seguinte sintaxe:

$ std :: mutex mut_x
$ mut_x. trancar ();
Void func_name ()
$ // Código que queremos esconder dos vários tópicos seriam escritos aqui
$ mut_x. desbloqueios ();

Agora usaremos essa sintaxe no exemplo fictício e no código pseudo (que não podemos simplesmente executar como é no editor de código) para que você saiba como podemos usar exatamente essa sintaxe, conforme mencionado no seguinte:

$ std :: mutex mut_x
Void Block ()
$ mut_x. trancar ();
$ std :: cout << “hello”;
$ mut_x. desbloqueios ();

Exemplo:

Neste exemplo, vamos tentar criar a operação multithread primeiro e depois cercar esta operação com bloqueio mutex e desbloqueio para fornecer a sincronização da operação ao código ou objeto criado. Mutex lida com condições de corrida, que são os valores bastante imprevisíveis e dependem da troca dos threads que são conscientes do tempo. Para implementar o exemplo do MUutex, primeiro precisamos importar as bibliotecas importantes e necessárias dos repositórios. As bibliotecas necessárias são:

$ # inclua
$ # inclua
$ # inclua

A biblioteca "iostream" nos fornece uma função para exibir os dados como cout, leia os dados como CIN e encerrar a instrução como endl. Usamos a biblioteca "Thread" para utilizar os programas ou funções dos threads. A biblioteca "Mutex" nos permite implementar o bloqueio mutex e o desbloqueio no código. Usamos o "# incluir" porque isso permite que todos os programas relacionados à biblioteca incluídos no código.

Agora, depois que a etapa anterior é concluída, definimos a classe Mutex ou uma variável global para o mutex usando o std. Em seguida, criamos uma função para bloqueio e desbloqueio mutex que poderíamos ligar depois no código. Neste exemplo, nomeamos esta função como bloco. No corpo da função de bloco, primeiro chamamos de “Mutex.Lock () ”e comece a escrever a lógica do código.

O mutex.Lock () nega o acesso dos outros threads para alcançar nosso objeto ou código criado, para que apenas um tópico possa ler nosso objeto ao mesmo tempo. Na lógica, executamos um loop for que é executado no índice de 0 a 9. Exibimos os valores no loop. Uma vez que essa lógica é criada no MUTEX Lock após a operação ou depois de sair da lógica, chamamos o “Mutex.desbloqueio () ”método. Esta chamada de método nos permite desbloquear o objeto criado do mutex bloqueio, pois o acesso do objeto a um único thread foi fornecido anteriormente e uma vez que a operação nesse objeto é feita por um thread de uma só vez. Agora queremos que os outros threads acessem esse objeto ou código também. Caso contrário, nosso código se move na situação de "impasse" que faz com que o objeto criado com o mutex permaneça na situação bloqueada para sempre e nenhum outro tópico seria capaz de acessar esse objeto. Portanto, uma operação incompleta continua executando. Depois disso, saímos da função do bloco e nos movemos para o principal.

No Main, simplesmente exibimos nosso mutex criado, criando os três threads usando o “std :: thread thread_name (chamando a função de bloco já criada aqui na qual criamos o mutex)” com os nomes Thread1, Thread2 e Thread3, etc. Dessa forma, os três tópicos são criados. Em seguida, juntamos esses três threads para serem executados simultaneamente chamando o "Thread_name. junção () ”método. E então, retornamos o valor igual a zero. A explicação mencionada anteriormente do exemplo é implementada na forma do código que pode ser mostrado na figura a seguir:

Na saída do código, podemos ver a execução e a exibição de todos os três threads um por um. Podemos ver mesmo que nosso aplicativo se enquadra na categoria de multithreading. Ainda assim, nenhum dos threads substituiu ou modificou os dados e compartilhou o recurso modificado devido à implementação do mutex do "bloco de funções".

Conclusão

Este guia fornece uma explicação detalhada do conceito de função mutex usada em c++. Discutimos quais são os aplicativos multithreading, quais problemas precisamos encontrar em aplicativos multithreading e por que precisamos implementar o Mutex para aplicativos multithreading. Em seguida, discutimos a sintaxe para o mutex com o exemplo fictício usando o pseudo-código. Em seguida, implementamos um exemplo completo sobre os aplicativos multithreading com o mutex no C ++ Visual Studio.