Questão 67123

Um professor de Sistemas Operacionais está lecionando sobre concorrência e o problema da 'seção crítica'. Ele quer que seus alunos compreendam por que o acesso concorrente a recursos compartilhados precisa ser controlado para evitar condições de corrida (race conditions). Para isso, ele usa um exemplo clássico: dois processos que tentam incrementar uma mesma variável compartilhada. Ele explica: "Uma condição de corrida ocorre quando o resultado de uma computação depende da ordem imprevisível de execução de eventos concorrentes. Considere a operação `contador++`. Em nível de linguagem de máquina, ela não é atômica. Ela é decomposta em três instruções: (1) carregar o valor de `contador` da memória para um registrador da CPU, (2) incrementar o registrador, (3) salvar o valor do registrador de volta na memória. Se o escalonador de processos interromper um processo no meio dessa sequência, o resultado pode ser incorreto." Ele então propõe o seguinte cenário, com a variável `contador` iniciando em 50:

1. **Processo A** lê o valor de `contador` (50) para seu registrador. 2. **Processo A** incrementa seu registrador (para 51). 3. **INTERRUPÇÃO:** O sistema operacional troca o contexto para o Processo B, antes que o Processo A possa salvar seu resultado. 4. **Processo B** lê o valor de `contador` da memória (que ainda é 50). 5. **Processo B** incrementa seu registrador (para 51). 6. **Processo B** salva seu resultado (51) de volta em `contador`. Agora, `contador` = 51. 7. **INTERRUPÇÃO:** O sistema operacional troca o contexto de volta para o Processo A. 8. **Processo A** continua de onde parou e executa sua última instrução: salvar seu registrador (que contém 51) de volta em `contador`.

Qual é o valor final da variável `contador` e qual mecanismo de sincronização poderia ter evitado este problema?