C++ Mutex Lock

C Mutex Lock



C++ é conhecida por ser 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 thread é apenas para executar a operação de leitura que não causa problemas, pois o thread não é afetado pelo que os outros threads estão fazendo naquele momento. Mas se esses threads tiverem que compartilhar os recursos entre eles, um thread pode modificar os dados naquele momento, o que causa o problema. Para lidar com este problema, temos o C++ “Mutex” que impede o acesso de vários recursos ao nosso código/objeto, fornecendo a sincronização que afirma que o acesso ao objeto/código pode ser fornecido a apenas uma thread por vez, para que vários threads não pudessem acessar esse objeto simultaneamente.

Procedimento:

Conheceremos como podemos interromper o acesso de vários threads a um objeto de uma só vez usando o bloqueio mutex. Falaremos sobre a sintaxe do mutex lock, o que é multiple threading e como podemos lidar com os problemas causados ​​por multiple threading usando o mutex lock. Em seguida, tomaremos um exemplo do encadeamento múltiplo e implementaremos o bloqueio mutex neles.







Sintaxe:

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



$ padrão :: mutex mut_x

$mut_x. trancar ( ) ;

Anular nome_função ( ) {

$ // o código que queremos esconder dos vários threads seria escrito aqui

$mut_x. desbloqueia ( ) ;

}

Agora usaremos essa sintaxe no exemplo fictício e no pseudocódigo (que não podemos simplesmente executar como está no editor de código) para que você saiba como podemos usar exatamente essa sintaxe conforme mencionado a seguir:



$ padrão :: mutex mut_x

Bloqueio de vazio ( ) {

$mut_x. trancar ( ) ;

$ padrão :: cout << 'olá' ;

$mut_x. desbloqueia ( ) ;

}

Exemplo:

Neste exemplo, vamos tentar primeiro criar a operação multithread e, em seguida, envolver essa operação com mutex lock e unlock para fornecer a sincronização da operação com o código ou objeto criado. Mutex lida com condições de corrida que são os valores que são bastante imprevisíveis e são dependentes da comutação dos threads que são conscientes do tempo. Para implementar o exemplo para mutex, primeiro precisamos importar as bibliotecas importantes e necessárias dos repositórios. As bibliotecas necessárias são:





$ # inclui

$ # inclui

$ # inclui

A biblioteca “iostream” nos fornece uma função para exibir os dados como Cout, ler os dados como Cin e encerrar a instrução como endl. Usamos a biblioteca “thread” para utilizar os programas ou funções das threads. A biblioteca “mutex” nos permite implementar tanto o bloqueio quanto o desbloqueio do mutex no código. Usamos o “# include” porque isso permite todos os programas relacionados à biblioteca incluídos no código.

Agora, após a etapa anterior, 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 de mutex que poderíamos chamar posteriormente no código. Neste exemplo, nomeamos essa função como bloco. No corpo da função de bloco, primeiro chamamos o “mutex.lock()” e começamos a escrever a lógica do código.



O mutex.lock() nega o acesso de outras threads para alcançar nosso objeto ou código criado para que apenas uma thread possa ler nosso objeto de cada vez. Na lógica, executamos um loop for que é executado no índice de 0 a 9. Exibimos os valores no loop. Uma vez que esta lógica é criada no mutex lock após a sua operação ou após sair da lógica, chamamos o método “mutex.unlock()”. Essa chamada de método nos permite desbloquear o objeto criado do mutex lock, 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 cada 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 “deadlock” que faz com que o objeto criado com o mutex permaneça na situação bloqueada para sempre e nenhum outro thread poderá acessar esse objeto. Portanto, uma operação incompleta continua sendo executada. Depois disso, saímos da função block e passamos para a main.

No principal, 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. Desta forma, os três threads são criados. Em seguida, juntamos esses três threads para serem executados simultaneamente chamando o método “thread_name. join()”. E então, retornamos o valor igual a zero. A explicação do exemplo mencionada anteriormente é 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 exibição de todas as três threads uma a uma. Podemos ver mesmo se nosso aplicativo se enquadra na categoria de multithreading. Ainda assim, nenhuma das threads sobrescreveu ou modificou os dados e compartilhou o recurso modificado por causa da implementação do mutex do “bloco de função”.

Conclusão

Este guia fornece uma explicação detalhada do conceito da função mutex usada em C++. Discutimos quais são os aplicativos multithreading, quais problemas temos que encontrar em aplicativos multithreading e por que precisamos implementar o mutex para aplicativos multithreading. Em seguida, discutimos a sintaxe do mutex com o exemplo fictício usando o pseudocódigo. Em seguida, implementamos um exemplo completo nos aplicativos multithreading com o mutex no visual studio C++.