0Pricing
Kotlin Academy · Lekcja

Aktory i strukturalne zarządzanie stanem

Używaj wzorców w stylu aktorów do szeregowania dostępu do stanu w kodzie współbieżnym.

Aktory i strukturalne zarządzanie stanem to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Czym jest aktor?

Aktor to korutyna, która posiada prywatny, mutowalny stan i komunikuje się za pośrednictwem kanału. Kod zewnętrzny nigdy nie uzyskuje bezpośredniego dostępu do tego stanu — korzysta wyłącznie z komunikatów.

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

Korzystanie z aktora

Komunikaty do aktora należy wysyłać za pomocą send. Aktor przetwarza je pojedynczo, szeregowo uzyskując dostęp do stanu.

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

Aktor zastępuje Mutex

Aktorzy eliminują potrzebę używania mutexów, ponieważ z założenia zapewniają sekwencyjny dostęp do stanu. Wszystkie modyfikacje zachodzą wewnątrz jednej korutyny.

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

Typowany protokół komunikatów

Protokół komunikatów należy zdefiniować jako hierarchię klas sealed, aby zapewnić pełną obsługę przypadków w wyrażeniu when aktora.

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

Maszyna stanów jako aktor

Aktorzy są naturalnymi maszynami stanów: wewnętrzne przejścia między stanami zachodzą atomowo w odpowiedzi na komunikaty.

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

Konstruktor actor()

Konstruktor korutyny actor { } tworzy aktora ze skrzynką odbiorczą w postaci kanału. Aktor to korutyna, która przetwarza komunikaty z kanału 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
}

Zatrzymywanie aktora

Proszę zamknąć kanał wysyłania aktora za pomocą close(). Pętla for w aktorze kończy działanie, umożliwiając wykonanie operacji porządkowych przed zakończeniem korutyny.

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

Aktorzy z mechanizmem backpressure

Proszę ustawić pojemność kanału aktora, aby zastosować mechanizm backpressure — nadawcy są wstrzymywani, gdy skrzynka odbiorcza jest pełna.

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

Wydajność aktora a Mutex

Aktorzy szeregowo obsługują dostęp bez rywalizacji o blokadę i dobrze nadają się do złożonego stanu z wieloma typami komunikatów. Mutex jest prostszy w przypadku pojedynczego współdzielonego licznika, ale trudniej go komponować.

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 w obsłudze żądanie–odpowiedź

W przypadku wzorców żądanie–odpowiedź wewnątrz aktora proszę umieścić CompletableDeferred w komunikacie. Aktor go uzupełnia, a nadawca oczekuje na jego wynik.

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

Nowoczesna alternatywa: StateFlow + coroutineScope

Konstruktor actor jest eksperymentalny i może zostać oznaczony jako przestarzały. Nowoczesną alternatywą jest klasa ViewModel lub klasa usługi z obiektem MutableStateFlow aktualizowanym z poziomu pojedynczej korutyny.

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

Szybkie sprawdzenie

Jak aktorzy zapewniają bezpieczny współbieżny dostęp do stanu?

Podsumowanie

Aktorzy hermetyzują zmienny stan w pojedynczej korutynie i udostępniają operacje jako komunikaty kanału o określonych typach. W naturalny sposób szeregowo obsługują dostęp, obsługują maszyny stanów i eliminują rywalizację o blokady — kosztem dodatkowej warstwy przekazywania komunikatów.

Często zadawane pytania

Czy lekcja „Aktory i strukturalne zarządzanie stanem” jest bezpłatna?

Tak — pełny tekst „Aktory i strukturalne zarządzanie stanem” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Aktory i strukturalne zarządzanie stanem”?

Używaj wzorców w stylu aktorów do szeregowania dostępu do stanu w kodzie współbieżnym. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Aktory i strukturalne zarządzanie stanem”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podstawy Channel: send, receive i close
  2. Typy Channel: Rendezvous, Buffered, Conflated, Unlimited
  3. Mutex i Semaphore dla współdzielonego stanu
  4. Aktory i strukturalne zarządzanie stanem
← Powrót do Kotlin Academy