Bloqueando recursos para execução de threads
As vezes é necessario que suas Threads acessem o mesmo objetos e modifiquem valores nesses objetos.
Porém se você estiver trabalhando com um computador multi-processado, por vezes os resultados serão errados pois uma thread vai desfazer o que a outra já fez.
Vou explicar melhor essa historia.
Exemplo Classico:
Temos um contador numa classe X
int contador = 0;
Só existe uma instancia da classe X no seu programa, e toda vez que suas threads fizerem determinada atividade,elas devem incrementar em 1 esse contador.
Nada mais normal do que a classe X possuir um metodo
public void AtualizaContador(){
contador++;
}
Para esse simples exemplo não estamos levando em conta as boas praticas e questões de encapsulamento que são muito importantes também.
Agora num ambiente multi-processado, imagine 2 Threads no mesmo momento tentando fazer a atualização do contador.
Suponto que nesse ponto o contador tenha o valor 10
De maneira generica, para fazer a atualização, os passos dados pelo processador seriam:
- Salvar o valor 10 no registrador do processador
- Incrementar o valor contido no registrador em 1
- retornar o valor para memoria
Voltando ao exemplo...
Se duas Threads pegassem ao mesmo tempo o valor 10
as duas iriam incrementar o valor para 11
porem na hora de salvar em memoria, uma delas ira salvar primeiro o valor 11
por consequencia a outra deveria salvar o valor 12 mas isso não acontece,
ela salva o valor 11 novamente por cima do valor 11 que já estava lá
Causando uma inconsistencia nos dados da nossa aplicação.
Temos diversas formas de tratar isso, principalmente porque incrementação é uma operação thread safe,então temos classes e metodos para tratar especificamente dessa situação.
Mas vamos tratar aqui como se fosse uma situação generica.
Dessa forma usaremos o lock do C#
De maneira muito simples de usar, o lock irá bloquear os recursos do objeto até que a thread que está utilizando o trecho do codigo acabe de processa-lo
Teriamos então o seguinte codigo:
public void AtualizaContador(){
lock(this){
contador++;
}
}
o lock recebe como parametro o this que é uma palavra reservada do C# que referencia o objeto em questão.
No caso, como o metodo está dentro da classe X o this então, representa a classe X
É como se a propria classe estivesse se referenciando.
Espero ter conseguido passar um pouco da importancia do lock.
Existem outras formas de fazer isso, mas seria bom que entrassemos em outras discussões como dead lock e etc...
então trarei isso em um outro post.
Talvez vocês não enxerguem a importancia disso num exemplo simples como esse, mas em ambientes complexos isso toma proporções enormes.
Espero ter ajudado
Até a proxima.