0Pricing
Kotlin Academy · Урок

Акторы и структурированное управление состоянием

Используйте шаблоны в стиле акторов для последовательного доступа к состоянию в параллельном коде.

«Акторы и структурированное управление состоянием» — бесплатный урок Kotlin Academy на CoddyKit. Это урок 4 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Kotlin Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Kotlin Academy содержит 4 уроков всего.

Что такое актор?

Актор — это сопрограмма, владеющая закрытым изменяемым состоянием и взаимодействующая с другими компонентами через канал. Внешний код никогда не обращается к состоянию напрямую, а делает это только с помощью сообщений.

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

Использование актора

Отправляйте актору сообщения с помощью send. Актор обрабатывает их по одному, последовательно предоставляя доступ к состоянию.

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

Актор вместо взаимной блокировки

Акторы устраняют необходимость во взаимных блокировках, поскольку по своей конструкции обеспечивают последовательный доступ к состоянию. Все изменения выполняются внутри одной сопрограммы.

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

Типизированный протокол сообщений

Определите протокол сообщений в виде иерархии запечатанных классов для исчерпывающей обработки в выражении выбора актора.

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

Конечный автомат в виде актора

Акторы естественным образом подходят для реализации конечных автоматов: переходы внутреннего состояния атомарно выполняются в ответ на сообщения.

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

Построитель актора

Построитель корутин actor { } создаёт актора с каналом входящих сообщений. Актор — это корутина, которая обрабатывает сообщения из 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
}

Остановка актора

Закройте канал отправки актора с помощью close(). Цикл внутри актора завершается, позволяя выполнить очистку до завершения корутины.

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

Акторы с обратным давлением

Задайте ёмкость канала актора, чтобы применить обратное давление: отправители приостанавливаются, когда входной канал заполнен.

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

Производительность: актор и мьютекс

Акторы обеспечивают последовательный доступ без конкуренции за блокировки и подходят для сложного состояния с несколькими типами сообщений. Мьютекс проще использовать для одного общего счётчика, но он хуже подходит для композиции.

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 для запроса и ответа

Для шаблонов запроса и ответа внутри актора добавьте в сообщение CompletableDeferred. Актор завершает его, а отправитель ожидает результат.

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

Современная альтернатива: StateFlow + coroutineScope

Построитель actor является экспериментальным и может быть объявлен устаревшим. Современная альтернатива — класс ViewModel или сервис с MutableStateFlow, который обновляется из одной корутины.

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

Быстрая проверка

Как акторы обеспечивают безопасный параллельный доступ к состоянию?

Итоги

Акторы инкапсулируют изменяемое состояние в одной корутине и предоставляют операции в виде типизированных сообщений канала. Они естественным образом обеспечивают последовательный доступ, поддерживают автоматы состояний и устраняют конкуренцию за блокировки — ценой косвенности обмена сообщениями.

Часто задаваемые вопросы

Урок «Акторы и структурированное управление состоянием» бесплатный?

Да — полный текст урока «Акторы и структурированное управление состоянием» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Kotlin Academy, подпишись на CoddyKit PRO. Курс Kotlin Academy содержит 4 уроков всего.

Чему я научусь в уроке «Акторы и структурированное управление состоянием»?

Используйте шаблоны в стиле акторов для последовательного доступа к состоянию в параллельном коде. Ты практикуешь Kotlin Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Kotlin Academy?

Предыдущий опыт не требуется. Kotlin Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 4 из 4.

Сколько времени занимает урок «Акторы и структурированное управление состоянием»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Kotlin Academy?

Да. Каждый урок Kotlin Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Основы каналов: send, receive и close
  2. Типы каналов: Rendezvous, Buffered, Conflated, Unlimited
  3. Mutex и Semaphore для общего состояния
  4. Акторы и структурированное управление состоянием
← Назад к Kotlin Academy