How do Coroutine Actors help avoid race conditions when performing parallel operations?

Coroutine Actors are a pattern in Kotlin Coroutines that helps manage state and perform parallel operations without race conditions.

How it works:

• Actor is a coroutine that sequentially processes incoming messages (commands).
• All state changes occur within this coroutine, ensuring sequential access to data.
• Other coroutines interact with the Actor by sending messages, without directly modifying the state.

Thus, race conditions are eliminated because there is no parallel access to shared state — all operations are performed sequentially inside the Actor.

Example:

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)
        }
    }
}

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

This approach simplifies writing safe parallel code without using locks and complex synchronization mechanisms.