Como é que os Coroutine Actors ajudam a evitar condições de corrida ao executar operações paralelas?

Os atores de coroutine são um padrão no Kotlin Coroutines que ajuda a gerir o estado e a realizar operações paralelas sem condições de corrida.

Como funciona:

• Um ator é uma coroutine que processa sequencialmente as mensagens recebidas (comandos).
• Todas as alterações de estado ocorrem dentro desta coroutine, garantindo acesso sequencial aos dados.
• Outras coroutines interagem com o ator enviando mensagens, sem alterar diretamente o estado.

Desta forma, evita-se a condição de corrida porque não há acesso paralelo ao estado compartilhado — todas as operações são realizadas por ordem dentro do ator.

Exemplo:

sealed class CounterMsg
object IncCounter : CounterMsg()
class GetCounter(val response: CompletableDeferred<Int>) : CounterMsg()

fun CoroutineScope.counterActor() = actor<CounterMsg> {
    var counter = 0
    for (msg in channel) {
        when (msg) {
            is IncCounter -> counter++
            is GetCounter -> msg.response.complete(counter)
        }
    }
}

// Uso
val counter = counterActor()
counter.send(IncCounter)
val response = CompletableDeferred<Int>()
counter.send(GetCounter(response))
println("Counter = ${response.await()}")

Este método simplifica a escrita de código paralelo seguro sem usar bloqueios e mecanismos de sincronização complexos.