Koje elemente višestrukog izvršavanja pruža Kotlin…

Kotlin pruža sledeće elemente višestrukog izvršavanja:

Korutine: Laganiji tokovi zasnovani na funkcijama koje se mogu pauzirati. Obezbeđuju asinhrono i neblokirajuće izvršavanje koda.

Konstruktori korutina: Funkcije koje pokreću korutine. Glavni: launch (pokreće korutinu bez vraćanja vrednosti), async (pokreće korutinu i vraća Deferred, koji se može čekati na dobijanje rezultata).

// Primer korišćenja launch
GlobalScope.launch {
    println("Zdravo iz korutine ${Thread.currentThread().name}")
}

// Primer korišćenja async
val deferred = GlobalScope.async {
    delay(1000) // Simuliramo dugu operaciju
    "Rezultat"
}
val result = runBlocking { deferred.await() } // Čekamo rezultat

Dispatchers: Određuju na kojem pool-u niti će se izvršiti korutina. Glavni:
- Dispatchers.Default: Opšti pool niti za CPU-intenzivne zadatke.
- Dispatchers.IO: Pool niti za blokirajuće operacije ulaza/izlaza.
- Dispatchers.Main: Dispečer za nit korisničkog interfejsa na odgovarajućim platformama (Android, Swing).
- Dispatchers.Unconfined: Korutina se pokreće u trenutnoj niti, ali može biti nastavljena u bilo kojoj niti.
```
GlobalScope.launch(Dispatchers.IO) {
    // Izvršavanje ulaza/izlaza
}
```
runBlocking: Funkcija-izgraditelj korutine koja blokira trenutnu nit do završetka korutine. Koristi se za kombinovanje blokirajućeg i neblokirajućeg koda, često u testovima ili glavnim funkcijama.
```
runBlocking {
    launch {
        delay(500)
        println("Završeno u ${Thread.currentThread().name}")
    }
    println("Pokrenuto u ${Thread.currentThread().name}")
}
```
suspend funkcije: Funkcije čiji se izvršavanje može pauzirati i nastaviti. Mogu biti pozvane samo iz drugih suspend funkcija ili konstruktora korutina.
```
suspend fun doSomething() {
    delay(100) // Primer pauziranja
}
```

Job: Rukovalac na pokrenutu korutinu. Pruža metode za upravljanje životnim ciklusom korutine (otkazivanje, čekanje na završetak).

val job = GlobalScope.launch {
   // Duga operacija
}
job.cancel() // Otkazivanje korutine
runBlocking { job.join() } // Čekanje na završetak

CoroutineScope: Definiše opseg vidljivosti za korutine. Korutine pokrenute u određenom opsegu automatski se otkazuju pri otkazivanju opsega. Pomaže u upravljanju životnim ciklusom korutina.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Korutina u ovom opsegu
}
scope.cancel() // Otkazivanje svih korutina u ovom opsegu
```

Kanali (Channel): Primitivi za siguran prenos podataka između korutina. Kanali mogu biti jednostrani (samo za slanje ili primanje) ili dvosmerni.

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Važno je zatvoriti kanal
    }
    launch {
        for (y in channel) println(y)
    }
}

MUTEX-ovi (Mutex): Primitivi za sinhronizaciju za obezbeđivanje ekskluzivnog pristupa zajedničkom resursu. Obezbeđuju sigurnost niti, dozvoljavajući samo jednoj korutini da poseduje mutex u datom trenutku.

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}

Stanja (StateFlow, SharedFlow): Primitivi za rad sa tokovima podataka u kontekstu reaktivnog programiranja i višestrukog izvršavanja. StateFlow predstavlja "hladni" tok sa trenutnim stanjem, a SharedFlow je "vreli" tok za široko emitovanje podataka.

Koje elemente višestrukog izvršavanja pruža Kotlin?