PricingLoginStart free
Kotlin Academy · Lección

Actores y gestión estructurada del estado

Use patrones de estilo actor para serializar el acceso al estado en código concurrente.

Lección 4 de 413 pasos

Actores y gestión estructurada del estado es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué es un actor?

Un actor es una corrutina que posee un estado mutable privado y se comunica mediante un canal. El código externo nunca accede directamente al estado, sino únicamente a través de mensajes.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
sealed class CounterMsg
object Increment : CounterMsg()
class GetCount(val response: CompletableDeferred<Int>) : CounterMsg()
fun CoroutineScope.counterActor() = actor<CounterMsg> {
    var counter = 0
    for (msg in channel) {
        when (msg) {
            is Increment -> counter++
            is GetCount  -> msg.response.complete(counter)
        }
    }
}

Usar el actor

Envíe mensajes al actor utilizando send. El actor los procesa de uno en uno, serializando el acceso al estado.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
// (CounterMsg sealed class from previous scene)
fun main() = runBlocking {
    val counter = counterActor()
    repeat(100) { counter.send(Increment) }
    val response = CompletableDeferred<Int>()
    counter.send(GetCount(response))
    println("Count: ${response.await()}") // 100
    counter.close()
}

El actor sustituye a Mutex

Los actores eliminan la necesidad de usar mutexes al hacer que el acceso al estado sea secuencial por diseño. Todas las mutaciones se producen dentro de una única corrutina.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
sealed class Msg
object Inc : Msg()
data class Get(val d: CompletableDeferred<Int>) : Msg()
fun CoroutineScope.safeCounter() = actor<Msg> {
    var n = 0
    for (m in channel) when(m) {
        is Inc -> n++
        is Get -> m.d.complete(n)
    }
}
fun main() = runBlocking {
    val a = safeCounter()
    repeat(1000) { a.send(Inc) }
    val d = CompletableDeferred<Int>()
    a.send(Get(d))
    println(d.await()) // 1000
    a.close()
}

Protocolo de mensajes tipado

Defina el protocolo de mensajes como una jerarquía de clases sealed para gestionar exhaustivamente los casos en la expresión when del actor.

sealed class BankMsg
data class Deposit(val amount: Double) : BankMsg()
data class Withdraw(val amount: Double, val result: CompletableDeferred<Boolean>) : BankMsg()
data class Balance(val result: CompletableDeferred<Double>) : BankMsg()
// Actor holds balance privately — outside code sends messages only

Máquina de estados como actor

Los actores son máquinas de estados naturales: las transiciones del estado interno se producen de forma atómica como respuesta a los mensajes.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
enum class TrafficState { RED, GREEN, YELLOW }
fun CoroutineScope.trafficLight() = actor<Unit> {
    var state = TrafficState.RED
    for (msg in channel) {
        state = when (state) {
            TrafficState.RED    -> TrafficState.GREEN
            TrafficState.GREEN  -> TrafficState.YELLOW
            TrafficState.YELLOW -> TrafficState.RED
        }
        println("State: $state")
    }
}
fun main() = runBlocking {
    val light = trafficLight()
    repeat(6) { light.send(Unit) }
    light.close()
}

Constructor actor()

El constructor de corrutinas actor { } crea un actor con un buzón respaldado por un canal. El actor es una corrutina que procesa mensajes de channel.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.logActor() = actor<String>(capacity = Channel.BUFFERED) {
    val log = mutableListOf<String>()
    for (msg in channel) {
        log.add(msg)
        println("[LOG] $msg")
    }
    println("Log entries: ${log.size}")
}
fun main() = runBlocking {
    val logger = logActor()
    repeat(5) { logger.send("Event $it") }
    logger.close()
    // actor finishes after close
}

Detener un actor

Cierre el canal de envío del actor con close(). El bucle for del actor termina, lo que permite realizar tareas de limpieza antes de que finalice la corrutina.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val actor = actor<String> {
        for (msg in channel) println("Got: $msg")
        println("Actor done")
    }
    actor.send("hello")
    actor.send("world")
    actor.close()
    // Wait for actor to finish
    delay(50)
}

Actores con contrapresión

Establezca la capacidad del canal del actor para aplicar contrapresión: los emisores se suspenden cuando el buzón está lleno.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.slowProcessor() = actor<Int>(capacity = 2) {
    for (item in channel) {
        delay(100) // slow processing
        println("Processed: $item")
    }
}
fun main() = runBlocking {
    val proc = slowProcessor()
    repeat(5) { proc.send(it) } // sender suspends when capacity full
    proc.close()
}

Rendimiento: actor frente a Mutex

Los actores serializan el acceso sin contención de bloqueos y son adecuados para estados complejos con varios tipos de mensajes. Mutex es más sencillo para un único contador compartido, pero ofrece menos posibilidades de composición.

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
// For a simple counter: Mutex is fine
val mutex = Mutex()
var simpleCounter = 0
// For complex state + multiple operations: Actor is cleaner
// Actor: messages describe intent; state changes are encapsulated
fun main() = runBlocking { println("Choose based on state complexity") }

CompletableDeferred para solicitud-respuesta

Para implementar patrones de solicitud-respuesta dentro de un actor, incluya un CompletableDeferred en el mensaje. El actor lo completa y el emisor espera su resultado.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
data class Query(val key: String, val reply: CompletableDeferred<String?>)
fun CoroutineScope.cacheActor() = actor<Any> {
    val cache = mutableMapOf<String, String>()
    for (msg in channel) when (msg) {
        is Pair<*, *> -> cache[msg.first as String] = msg.second as String
        is Query -> msg.reply.complete(cache[msg.key])
    }
}

Alternativa moderna: StateFlow + coroutineScope

El constructor actor es experimental y podría quedar obsoleto. La alternativa moderna es una clase ViewModel o de servicio con un MutableStateFlow actualizado desde una única corrutina.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
class CounterService(scope: CoroutineScope) {
    private val _count = MutableStateFlow(0)
    val count = _count.asStateFlow()
    private val events = kotlinx.coroutines.channels.Channel<Unit>()
    init {
        scope.launch {
            for (e in events) _count.value++
        }
    }
    fun increment() { events.trySend(Unit) }
}

Comprobación rápida

¿Cómo garantizan los actores un acceso seguro al estado concurrente?

Responde en la lección interactiva

Repaso

Los actores encapsulan el estado mutable en una única corrutina y exponen las operaciones como mensajes tipados de un canal. Serializan el acceso de forma natural, admiten máquinas de estados y eliminan la contención de bloqueos, a cambio de introducir una indirección mediante paso de mensajes.

Gratis para empezar

Aprende Kotlin con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
51
Lecciones
203
Empezar a aprender gratisVer el curso completo

Preguntas frecuentes

¿La lección «Actores y gestión estructurada del estado» es gratis?

Sí — el texto completo de «Actores y gestión estructurada del estado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Actores y gestión estructurada del estado»?

Use patrones de estilo actor para serializar el acceso al estado en código concurrente. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Actores y gestión estructurada del estado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Fundamentos de Channel: send, receive y close
  2. Tipos de Channel: Rendezvous, Buffered, Conflated y Unlimited
  3. Mutex y Semaphore para el estado compartido
  4. Actores y gestión estructurada del estado
← Volver a Kotlin Academy