As vezes é necessário que suas Threads acessem os mesmos 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 Clássico:
Temos um contador numa classe X

int contador = 0;

Só existe uma instância da classe X no seu programa, e toda vez que suas threads fizerem determinada atividade, elas deve incrementar em 1 esse contador.

Nada mais normal do que a classe X possuir um método assim:

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.

Supondo que nesse ponto o contador tenha o valor 10.
De maneira genérica, para fazer a atualização, os passos dados pelo processador seriam:

1. Salvar o valor 10 no registrador do processador
2. Incrementar o valor contido no registrador em 1
3. retornar o valor para memória

Voltando ao exemplo…

Se duas Threads pegassem ao mesmo tempo o valor 10, as duas iam incrementar o valor para 11, porem na hora de salvar em memória, uma delas ia salvar primeiro o valor 11, por conseqüência 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 inconsistência 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 métodos para tratar especificamente dessa situação.

Mas vamos tratar aqui como se fosse uma situação genérica. 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 código acabe de processa-lo

Teríamos então o seguinte código:

public void AtualizaContador(){

lock(this){
contador++;
}
}

O lock recebe como parâmetro o this que é uma palavra reservada do C#, que referencia o objeto em questão. No caso, como o método está dentro da classe X, o this então, representa a classe X. É como se a própria classe estivesse se referenciando.

Espero ter conseguido passar um pouco da importância do lock.
Existem outras formas de fazer isso, mas teríamos que entrar em outras discussões como dead lock e etc… Então trarei isso em um outro post.
Talvez vocês não enxerguem a importância disso num exemplo simples como esse, mas em ambientes complexos isso toma proporções enormes.

Espero ter ajudado
Até a próxima.