Uma corrida de dados acontece quando duas threads tocam a mesma memória ao mesmo tempo, com pelo menos uma delas escrevendo, sem nada que as ordene. Em C++, isso é comportamento indefinido. O sintoma cotidiano é uma atualização perdida: balance_ += cents lê o saldo, soma e o escreve de volta, e se outra thread escrever no meio, um depósito desaparece.
Um std::mutex torna um bloco de código exclusivo: m.lock() espera até que nenhuma outra thread tenha o mutex, e m.unlock() deixa a próxima entrar. Três regras fazem isso funcionar: todo acesso aos dados compartilhados segura o mesmo mutex, leituras inclusive (senão um leitor pode ver meia atualização); o mutex fica junto dos dados que protege; e uma decisão e a ação a que ela leva ("sobrou o bastante? então pegue") acontecem sob um único bloqueio, não dois.
Esta lição chama lock() e unlock() à mão; a próxima os substitui por guards que não deixam você esquecer.
Aqui as threads são simuladas. Seu programa roda em uma única thread real enquanto um escalonador alterna entre suas threads nas leituras e escritas compartilhadas, nos bloqueios, nas operações atômicas, nas esperas, nos yields e nas pausas, e cada teste roda com 12 escalonamentos diferentes. A ordem em que as coisas podem acontecer, as corridas nesses pontos e os deadlocks são fiéis. O ganho real de velocidade paralela e os efeitos de ordens de memória fracas, não.
A leitura, a soma e a escrita acontecem enquanto nenhuma outra thread pode tocar em balance_.