Kako radite sa višestrukim nitima u Kotlinu?

U Kotlinu, za rad sa višestrukim nitima, uglavnom koristim korutine. One pružaju lakši i fleksibilniji pristup u poređenju sa tradicionalnim nitima, minimizirajući troškove i pojednostavljujući upravljanje paralelnim operacijama.

Ključni koncepti pri radu sa korutinama:

• Suspend funkcije: Funkcije koje mogu biti zaustavljene i nastavljene. One su osnova za asinhrone operacije u korutinama.

  suspend fun fetchData(): String {
      delay(1000) // Primer za zaustavljanje
      return "Podaci su preuzeti"
  }
  

• CoroutineScope: Definiše životni ciklus korutina i omogućava njihovo otkazivanje.

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // CoroutineScope za blokirajuće izvršavanje
      launch { // Kreiranje nove korutine u ovom Scope
          // Kod korutine
      }
  }
  

• Dispečeri (Dispatchers): Određuju skupinu niti na kojima će se izvršiti korutina.
  • Dispatchers.Default: Za intenzivne CPU računare.
  • Dispatchers.IO: Za blokirajuće I/O operacije (npr. mreža, fajlovi).
  • Dispatchers.Main: Za rad sa UI (dostupno na odgovarajućim platformama, npr. Android).
  • Dispatchers.Unconfined: Nije vezano za određeni skup niti.

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // Prebacivanje na I/O dispečer
          // Izvršavanje blokirajuće operacije
      }
  }
  

• Graditelji korutina (Coroutine Builders): Funkcije za pokretanje korutina.
  • launch: Pokreće korutinu i vraća Job, koji se može koristiti za otkazivanje.
  • async: Pokreće korutinu i vraća Deferred, koji omogućava dobijanje rezultata (await()).

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Paralelni zadatak
      }
  
      val deferredResult = async {
          // Zadatak koji vraća rezultat
          "Rezultat"
      }
  
      job.cancel() // Otkazivanje zadatka
      val result = deferredResult.await() // Dobijanje rezultata
  }
  

Za sinhronizaciju pristupa zajedničkim resursima koristim alate iz paketa kotlinx.coroutines.sync, kao što su Mutex ili Semaphore.

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Zaključavanje Mutex pre pristupa zajedničkom resursu
        counter++
    }
}

U nekim specifičnim slučajevima, kada je potrebna direktna kontrola niti na nižem nivou, mogu koristiti klase iz paketa java.util.concurrent ili direktno klase Thread i Runnable, iako se to koristi mnogo ređe nego korutine.

Prednosti korutina u poređenju sa tradicionalnim nitima:

Osobina	Korutine	Tradicionalne niti
Težina	Lagan, mnogo na jednoj niti	Teške, svaka nit zauzima resurse
Prebacivanje	Kooperativno (suspend/resume)	Prisilno (planer OS)
Otkazivanje	Lako i strukturirano	Složeno, zahteva upravljanje prekidima
Debagovanje	Pogodno, stog poziva se čuva	Može biti teško
Strukturiranost	Podržava strukturiranu konkurentnost	Manje strukturirano

Preferiram korutine zbog njihove efikasnosti, jednostavnosti pisanja asinhronog koda i bolje čitljivosti, posebno pri radu sa složenim nizovima asinhronih operacija.