Kotlin Academy · レッスン

Actorと構造化された状態管理

Q: 「Actorと構造化された状態管理」で何を学びますか？

Actorスタイルのパターンを使い、並行コードでの状態アクセスを直列化します。 ブラウザで直接実行するハンズオンコードでKotlin Academyを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Actorスタイルのパターンを使い、並行コードでの状態アクセスを直列化します。

レッスン 4/413 ステップ

「Actorと構造化された状態管理」はCoddyKit上の無料Kotlin Academyレッスンです。これはレッスン4/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはKotlin Academy学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Kotlin Academyコースには全4レッスンが含まれています。

Actorとは

アクターはプライベートな可変状態を所有し、チャネルを介して通信するコルーチンです。外部のコードが状態に直接アクセスすることはなく、メッセージを介してのみアクセスします。

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

Actorを使用する

sendを使ってアクターにメッセージを送信します。アクターはメッセージを1つずつ処理し、状態へのアクセスを直列化します。

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

ActorでMutexを置き換える

アクターは、設計上状態へのアクセスを順番に行うことで、Mutexを不要にします。すべての状態変更は1つのコルーチン内で行われます。

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の階層として定義すると、アクターのwhen式で網羅的に処理できます。

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() ビルダー

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()でアクターの送信チャネルを閉じます。アクター内のforループが終了するため、コルーチンの完了前に後片付けを行えます。

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

アクターと Mutex のパフォーマンス

アクターはロック競合なしにアクセスを直列化でき、複数のメッセージ型を持つ複雑な状態に適しています。Mutexは単一の共有カウンターにはより簡単ですが、組み合わせて使う柔軟性は低くなります。

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ビルダーは実験的な機能であり、非推奨になる可能性があります。現代的な代替手段は、MutableStateFlowを単一のコルーチンから更新するViewModelまたはサービスクラスです。

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

確認問題

アクターはどのようにして、並行処理で安全に状態へアクセスできるようにしていますか？

対話的なレッスンで答える

まとめ

アクターは可変状態を単一のコルーチン内にカプセル化し、操作を型付きチャネルメッセージとして公開します。アクセスを自然に直列化し、ステートマシンをサポートしてロック競合をなくせる一方、メッセージパッシングによる間接性というコストがあります。

無料で開始

AI チューターと学ぶ Kotlin — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース: 51
レッスン: 203

無料で学習を始めるコース全体を表示

よくある質問

「Actorと構造化された状態管理」レッスンは無料ですか？

はい。「Actorと構造化された状態管理」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Kotlin Academyコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Kotlin Academyコースには全4レッスンが含まれています。

「Actorと構造化された状態管理」で何を学びますか？

Actorスタイルのパターンを使い、並行コードでの状態アクセスを直列化します。ブラウザで直接実行するハンズオンコードでKotlin Academyを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Kotlin Academyを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのKotlin Academyは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン4/4です。

「Actorと構造化された状態管理」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このKotlin Academyレッスンでコードを書いて実行できますか？

はい。すべてのKotlin Academyレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

Channelの基本：send、receive、close
Channelの種類：Rendezvous、Buffered、Conflated、Unlimited
共有状態のためのMutexとSemaphore
Actorと構造化された状態管理

← Kotlin Academyに戻る