Kaip dirbate su daugiagijumu Kotlin?

Kotlin'e daugiafunkcinio darbo atžvilgiu dažniausiai naudoju korutinas. Jos siūlo lengvesnį ir lankstesnį požiūrį, palyginti su tradiciniais srautais, sumažindamos papildomas išlaidas ir supaprastindamos paralelinių operacijų valdymą.

Pagrindinės sąvokos dirbant su korutinomis:

• Suspend funkcijos: funkcijos, kurios gali būti sustabdytos ir atnaujintos. Jos yra pagrindas asinchroninėms operacijoms korutinose:

  suspend fun fetchData(): String {
      delay(1000) // Sustabdymo pavyzdys
      return "Gauti duomenys"
  }
  

• CoroutineScope: apibrėžia korutinų gyvavimo ciklą ir leidžia valdyti jų atšaukimą:

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // Blokuojantis vykdymas
      launch { // Naujos korutinos sukūrimas šiame Scope
          // Korutinos kodas
      }
  }
  

• Dispatchers (dispečeriai): apibrėžia siurblių grupę, kurioje bus vykdoma korutina:
  • Dispatchers.Default: CPU intensyvioms skaičiavimams
  • Dispatchers.IO: blokuojančiam I/O (pvz., tinklo ar failų operacijoms)
  • Dispatchers.Main: darbui su UI (pasiekiama atitinkamose platformose, pvz., Android)
  • Dispatchers.Unconfined: nėra susieta su konkrečiu siurbliu:

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // perjungimas į I/O dispečerį
          // Blokuojančios operacijos vykdymas
      }
  }
  

• Korutinų statybininkai (Coroutine Builders): funkcijos korutinų paleidimui:
  • launch: paleidžia korutiną ir grąžina Job, kurį galima naudoti jos atšaukimui
  • async: paleidžia korutiną ir grąžina Deferred, leidžiantį gauti rezultatą (await()):

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Paralelinis uždavinys
      }
  
      val deferredResult = async {
          // Grąžinantis rezultatą uždavinys
          "Rezultatas"
      }
  
      job.cancel() // Atšaukimas
      val result = deferredResult.await() // Rezultato gavimas
  }
  

Norint sinchronizuoti prieigą prie bendrų išteklių, naudoju kotlinx.coroutines.sync paketą, pavyzdžiui, Mutex arba Semaphore:

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Mutex užrakinimas prieš prieigą
        counter++
    }
}

Kai kuriais specifiniais atvejais, kai reikia tiesiogiai valdyti srautus žemame lygyje, naudoju java.util.concurrent paketą arba tiesiog Thread ir Runnable klases, nors tai yra daug rečiau nei korutinės.

Korutinos turi pranašumų lyginant su tradiciniais srautais:

Savybė	Korutinos	Tradiciniai srautai
Svoris	Lengvos, daugybė viename sraute	Sunkios, kiekvienas srautas reikalauja išteklių
Perjungimas	Kooperatyvinis (suspend/resume)	Priverstinis (OS planuotojas)
Atšaukimas	Lengvas ir struktūruotas	Sudėtingas, reikalauja pertraukimo apdorojimo
Detalių sekimas	Patogus, steko sekimas išsaugotas	Gali būti sudėtingas
Struktūriškumas	Palaiko struktūruotą konkurenciją	Mažiau struktūruotas

Aš teikiu pirmenybę korutinoms dėl jų efektyvumo, paprastumo rašyti asinchroninį kodą ir geresnio skaitomumo, ypač dirbant su sudėtingomis asinchroninėmis operacijų sekcijomis.