Kuidas te töötate Kotlinis mitmetöötlusega?

Kotlinis peamiselt kas hõlmab mitme niidi töötlust, kas kasutab korutinas. Need pakuvad kergemat ja paindlikumat lähenemist võrreldes traditsiooniliste voogudega, minimeerides lisakulusid ja lihtsustades paralleelsete operatsioonide juhtimist.

Korutinatega töötamisel põhiteadmised:

• Suspend-funktsioonid: funktsioonid, mida saab peatada ja uuesti alustada. Need on aluseks asünkroonsetele operatsioonidele korutinas:

  suspend fun fetchData(): String {
      delay(1000) // Peatamise näide
      return "Andmed saadud"
  }
  

• CoroutineScope: määratleb korutinate elutsükli ja võimaldab nende tühistamist:

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // Blokeeriv täitmine
      launch { // Uue korutina loomine selles Scope'is
          // Korutina kood
      }
  }
  

• Dispatchers (dispetšerid): määratleb niidupulga, millel korutina täidetakse:
  • Dispatchers.Default: CPU-intensiivsete arvutuste jaoks
  • Dispatchers.IO: blokeerivale I/O-le (nt võrgu- või failitöötlus)
  • Dispatchers.Main: UI-ga töötamiseks (saadaval vastavatel platvormidel, nt Android)
  • Dispatchers.Unconfined: ei ole seotud konkreetse niidupulgaga:

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // Ümberlülitus I/O dispetšerile
          // Blokeeriva operatsiooni täitmine
      }
  }
  

• Korutinate ehitajad (Coroutine Builders): funktsioonid korutinate käivitamiseks:
  • launch: käivitab korutina ja tagastab Job, mida saab kasutada selle tühistamiseks
  • async: käivitab korutina ja tagastab Deferred, mis võimaldab saada tulemuse (await()):

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Paralleelne ülesanne
      }
  
      val deferredResult = async {
          // Tulemuse tagastav ülesanne
          "Tulemus"
      }
  
      job.cancel() // Tühistamine
      val result = deferredResult.await() // Tulemuse saamine
  }
  

Kasutades ühiste ressursside juurdepääsu sünkroniseerimiseks, kasutan kotlinx.coroutines.sync paketi tööriistu, näiteks Mutex või Semaphore:

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Mutex-i lukustamine enne juurdepääsu
        counter++
    }
}

Mõnel spetsiifilisel juhul, kui on vaja otse juhtida niite madalal tasemel, kasutan java.util.concurrent paketi klasse või otse Thread ja Runnable klasse, kuigi see on palju harvem kui korutinasid.

Korutinate eelised võrreldes traditsiooniliste niitidega:

Omadus	Korutinasid	Traditsioonilised niidid
Kaal	Kerged, palju ühes niidis	Rasked, iga niit võtab ressursse
Ümberlülitus	Kooperatiivne (suspend/resume)	Sunniviisiline (OS-i ajastaja)
Tühistamine	Lihtne ja struktuuriline	Raske, nõuab katkestuste töötlemist
Detaile jälgimine	Mugav, virna jälgimine säilub	Võib olla keeruline
Struktureeritus	Toetab struktuurset konkurentsi	Vähem struktuurset

Ma eelistan korutinasid nende tõhususe, lihtsuse ja parema loetavuse tõttu, eriti töötades keerukate asünkroonsete operatsioonide järjestustega.