Como funciona um mutex em corrotinas?

O mutex (Mutual Exclusion) nas corrotinas fornece um mecanismo de exclusão mútua para proteger recursos partilhados contra acessos simultâneos por várias corrotinas.

Princípio de funcionamento:

Agarre do mutex: A corrotina que deseja aceder ao recurso protegido chama o método lock().
Bloqueio: Se o mutex estiver livre, a corrotina adquire-o sem bloquear e continua a execução. Se o mutex estiver ocupado por outra corrotina, a corrotina que chama é suspensa até que o mutex seja libertado.
Libertação do mutex: Após terminar o trabalho com o recurso protegido, a corrotina chama o método unlock() para libertar o mutex.

Características principais nas corrotinas:

lock() não bloqueante (quando um mutex livre é adquirido): Ao contrário dos threads tradicionais, onde lock() pode bloquear todo o thread, nas corrotinas, se o mutex estiver livre, a aquisição é feita sem bloqueio.
Suspensão da corrotina (quando o mutex está ocupado): Se o mutex estiver ocupado, a corrotina que chama não bloqueia o thread, mas é suspensa até que seja libertada. Isto liberta o thread para executar outras corrotinas.
Função de extensão withLock: Forma conveniente de usar o mutex, que o adquire e liberta automaticamente, mesmo que ocorra uma exceção dentro do bloco.

Exemplo de uso:

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        // Secção crítica - recurso protegido
        counter++
        delay(10) // Simulação de trabalho
        println("Counter: $counter")
    } // O mutex é libertado automaticamente aqui
}

fun main() = runBlocking {
    repeat(100) {
        launch {
            incrementCounter()
        }
    }
    delay(1000)
}

Neste exemplo, incrementCounter é uma secção crítica que modifica o recurso partilhado counter. O mutex garante que apenas uma corrotina acede a esta secção de cada vez, evitando condições de corrida. O uso de withLock simplifica a gestão do mutex.