0Pricing
Kotlin Academy · Ders

Actor'ler ve Yapılandırılmış Durum Yönetimi

Eşzamanlı kodda durum erişimini sıraya koymak için actor tarzı kalıpları kullanın.

Actor'ler ve Yapılandırılmış Durum Yönetimi, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Kotlin Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Kotlin Academy kursu toplamda 4 dersten oluşur.

Aktör Nedir?

Bir aktör, özel değiştirilebilir duruma sahip olan ve bir kanal üzerinden iletişim kuran bir korutindir. Dış kod duruma doğrudan erişemez; yalnızca iletiler üzerinden erişebilir.

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

Aktörü Kullanma

send kullanarak aktöre iletiler gönderin. Aktör bunları birer birer işler ve duruma erişimi sıralı hâle getirir.

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

Aktör, Karşılıklı Dışlama Kilidinin Yerine Geçer

Aktörler, duruma erişimi tasarım gereği sıralı hâle getirerek karşılıklı dışlama kilitlerine duyulan ihtiyacı ortadan kaldırır. Tüm değişiklikler tek bir korutinin içinde gerçekleşir.

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

Türü Belirlenmiş İleti Protokolü

Aktörün when ifadesinde tüm durumların ele alınabilmesi için ileti protokolünüzü mühürlü bir sınıf hiyerarşisi olarak tanımlayın.

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

Aktör Olarak Durum Makinesi

Aktörler doğal durum makineleridir: iç durum geçişleri, iletilere yanıt olarak atomik biçimde gerçekleşir.

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() Oluşturucusu

actor { } eş yordam oluşturucusu, kanal gelen kutusuna sahip bir aktör oluşturur. Aktör, channel kanalından gelen iletileri işleyen bir eş yordamdır.

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
}

Aktörü Durdurma

Aktörün gönderme kanalını close() ile kapatın. Aktördeki döngü sona erer ve eş yordam tamamlanmadan önce temizleme işlemlerinin yapılmasına olanak tanır.

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

Geri Basınçlı Aktörler

Geri basınç uygulamak için aktörün kanal kapasitesini ayarlayın; gelen kutusu dolduğunda göndericiler askıya alınır.

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

Aktör ve Kilit Performansı

Aktörler, kilit çekişmesi olmadan erişimi sıraya koyar ve birden çok ileti türü içeren karmaşık durumlar için uygundur. Kilit, tek bir paylaşılan sayaç için daha basittir ancak bileşimi daha zayıftır.

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

İstek-Yanıt için CompletableDeferred

Bir aktör içindeki istek-yanıt düzenleri için iletiye bir CompletableDeferred ekleyin. Aktör bunu tamamlar, gönderici de tamamlanmasını bekler.

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

Modern Alternatif: StateFlow + coroutineScope

actor oluşturucusu deneyseldir ve kullanımdan kaldırılabilir. Modern alternatif, tek bir eş yordamdan güncellenen MutableStateFlow kullanan bir ViewModel veya hizmet sınıfıdır.

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

Hızlı Kontrol

Aktörler eş zamanlı durum erişiminin güvenli olmasını nasıl sağlar?

Özet

Aktörler, değiştirilebilir durumu tek bir eş yordam içinde kapsüller ve işlemleri türü belirlenmiş kanal iletileri olarak sunar. Erişimi doğal olarak sıraya koyar, durum makinelerini destekler ve kilit çekişmesini ortadan kaldırır; bunun karşılığında ileti aktarımı yönlendirmesi eklenir.

Sıkça Sorulan Sorular

“Actor'ler ve Yapılandırılmış Durum Yönetimi” dersi ücretsiz mi?

Evet — “Actor'ler ve Yapılandırılmış Durum Yönetimi” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Kotlin Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Kotlin Academy kursu toplamda 4 dersten oluşur.

“Actor'ler ve Yapılandırılmış Durum Yönetimi” dersinde ne öğreneceğim?

Eşzamanlı kodda durum erişimini sıraya koymak için actor tarzı kalıpları kullanın. Kotlin Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Kotlin Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Kotlin Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Actor'ler ve Yapılandırılmış Durum Yönetimi” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Kotlin Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Kotlin Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Channel Temelleri: send, receive ve close
  2. Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited
  3. Paylaşılan Durum için Mutex ve Semaphore
  4. Actor'ler ve Yapılandırılmış Durum Yönetimi
← Kotlin Academy Sayfasına Dön