Paylaşılan Durum için Mutex ve Semaphore
Paylaşılan değiştirilebilir durumu Mutex ile koruyun ve Semaphore ile eşzamanlılığı sınırlayın.
Paylaşılan Durum için Mutex ve Semaphore, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 3. 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.
Paylaşılan Durum Sorunu
Birden çok iş parçacığındaki korutinler, paylaşılan değiştirilebilir durumu bozabilir. Eşzamanlama olmadan eşzamanlı artırmalar yanlış sonuçlar üretir.
import kotlinx.coroutines.*
fun main() = runBlocking {
var counter = 0
val jobs = List(1000) {
launch(Dispatchers.Default) { counter++ } // race condition!
}
jobs.forEach { it.join() }
println("Expected 1000, got: $counter") // likely wrong
}Karşılıklı Dışlama Kilidinin Temelleri
Mutex, korutinler için karşılıklı dışlama kilididir. Kilit kullanılabilir olana kadar çağıranı engellemek yerine askıya alır.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
fun main() = runBlocking {
val mutex = Mutex()
var counter = 0
val jobs = List(1000) {
launch(Dispatchers.Default) {
mutex.withLock { counter++ } // safe
}
}
jobs.forEach { it.join() }
println("Counter: $counter") // 1000
}withLock Uzantısı
mutex.withLock { ... }, kilidi alır, bloğu çalıştırır ve istisna veya iptal durumunda bile kilidi serbest bırakır.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
fun main() = runBlocking {
val mutex = Mutex()
var list = mutableListOf<Int>()
List(10) {
launch {
mutex.withLock {
list.add(it)
}
}
}.forEach { it.join() }
println(list.sorted())
}lock / unlock İşlemlerini Elle Kullanma
Daha ayrıntılı denetim için lock() ve unlock() öğelerini doğrudan çağırabilirsiniz; ancak kilidi serbest bırakmayı unutmamak için withLock öğesini tercih edin.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
fun main() = runBlocking {
val mutex = Mutex()
mutex.lock()
try {
println("Critical section")
} finally {
mutex.unlock() // must always release
}
}Karşılıklı Dışlama Kilidi Yeniden Girişli Değildir
Kotlin'in Mutex öğesi NOT yeniden girişlidir. Aynı korutinden yeniden lock() çağırmak karşılıklı kilitlenmeye neden olur. İç içe kilitlemeden kaçınmak için bir counter kullanın veya yapıyı yeniden düzenleyin.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
fun main() = runBlocking {
val mutex = Mutex()
// This deadlocks:
// mutex.withLock { mutex.withLock { println("never") } }
mutex.withLock {
println("Acquired once — safe")
}
}Semaforun Temelleri
Bir Semaphore(n), en fazla n korutinin eşzamanlı olarak ilerlemesine izin verir. Bunu n yuvalı bir bilet sistemi gibi düşünebilirsiniz.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
fun main() = runBlocking {
val semaphore = Semaphore(3) // max 3 concurrent
List(10) { i ->
launch {
semaphore.withPermit {
println("Concurrent task $i"); delay(100)
}
}
}.forEach { it.join() }
}withPermit Uzantısı
semaphore.withPermit { ... }, bir izin alır, bloğu çalıştırır ve izni serbest bırakır; bu, semafor için korutin güvenli try-acquire eşdeğeridir.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
fun main() = runBlocking {
val sem = Semaphore(2)
val results = mutableListOf<String>()
List(5) { i ->
launch {
sem.withPermit {
delay(50)
synchronized(results) { results.add("task-$i") }
}
}
}.forEach { it.join() }
println(results)
}Semaforla Hız Sınırlama
Eşzamanlı API çağrılarını hızla sınırlamak için semafor kullanın; aynı anda N istekle sınırlandırın.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
val apiSemaphore = Semaphore(5) // max 5 concurrent requests
suspend fun callApi(id: Int): String {
return apiSemaphore.withPermit {
delay(100) // simulate network
"Response-$id"
}
}
fun main() = runBlocking {
val results = (1..20).map { async { callApi(it) } }.awaitAll()
println("Got ${results.size} responses")
}Karşılıklı Dışlama Kilidi ve Semafor Karşılaştırması
Karşılıklı dışlama kilidi: özel erişim için kullanılan ikili semafor (1 izin). Semaphore(n): sınırlı eşzamanlılık için n izin. Bir kaynağı korumak için karşılıklı dışlama kilidi, paralelliği sınırlamak için semafor kullanın.
import kotlinx.coroutines.sync.*
// Mutex = Semaphore(1) for exclusive access
// Semaphore(n) = n-way concurrency limit
val exclusive = Mutex() // one at a time
val limited = Semaphore(3) // three at a time
fun main() { println("Mutex for exclusion; Semaphore for rate limiting") }Karşılıklı Dışlama Kilidiyle Atomik Sayaç
Artırma ve okuma işlemlerini korumak için Mutex kullanarak iş parçacığı güvenli bir sayaç sınıfı uygulayın.
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*
class AtomicCounter {
private val mutex = Mutex()
private var count = 0
suspend fun increment() = mutex.withLock { count++ }
suspend fun get() = mutex.withLock { count }
}
fun main() = runBlocking {
val counter = AtomicCounter()
List(100) { launch { counter.increment() } }.forEach { it.join() }
println("Count: ${counter.get()}")
}Alternatif: Tek İş Parçacıklı Dağıtıcı
Karşılıklı dışlama kilidi yerine değiştirilebilir durumu tek iş parçacıklı bir dağıtıcıyla sınırlandırın. Bu dağıtıcıda aynı anda yalnızca bir korutin çalışır; böylece erişim kendiliğinden güvenli olur.
import kotlinx.coroutines.*
fun main() = runBlocking {
val singleThread = newSingleThreadContext("CounterThread")
var counter = 0
List(1000) {
launch(singleThread) { counter++ }
}.forEach { it.join() }
println("Counter: $counter") // 1000, no mutex needed
singleThread.close()
}Hızlı Kontrol
Mutex ile Semaphore arasındaki temel fark nedir?
Özet
Karşılıklı dışlama kilidi, paylaşılan duruma özel erişim sağlar; withLock öğesini tercih edin. Semafor(n), eşzamanlılığı n ile sınırlar. Her ikisi de bekleyen korutinleri engellemek yerine askıya alır. Basit durumlarda tek iş parçacıklı dağıtıcı genellikle daha temiz bir çözümdür.
Sıkça Sorulan Sorular
“Paylaşılan Durum için Mutex ve Semaphore” dersi ücretsiz mi?
Evet — “Paylaşılan Durum için Mutex ve Semaphore” 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.
“Paylaşılan Durum için Mutex ve Semaphore” dersinde ne öğreneceğim?
Paylaşılan değiştirilebilir durumu Mutex ile koruyun ve Semaphore ile eşzamanlılığı sınırlayı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 3. dersidir.
“Paylaşılan Durum için Mutex ve Semaphore” 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
- Channel Temelleri: send, receive ve close
- Channel Türleri: Rendezvous, Buffered, Conflated, Unlimited
- Paylaşılan Durum için Mutex ve Semaphore
- Actor'ler ve Yapılandırılmış Durum Yönetimi