Hoe kun je werken met multithreading in Kotlin?

In Kotlin kan concurrency op verschillende manieren worden geïmplementeerd, elk met zijn eigen voordelen afhankelijk van de taak:

1. Klassieke JVM-threads (java.lang.Thread): We gebruiken direct de Java API.

   // Creëer en start een nieuwe thread
   Thread {
       // Code die in een aparte thread wordt uitgevoerd
       println("Hallo vanaf de thread!")
   }.start()
   

2. Executors (java.util.concurrent pakket): Flexibeler beheer van thread pools.

   // Gebruik van een vaste thread pool
   import java.util.concurrent.Executors
   
   val executor = Executors.newFixedThreadPool(4)
   
   executor.submit {
       // Taak uit te voeren in de pool
       println("Taak wordt uitgevoerd in de pool")
   }
   
   // Vergeet niet de pool te sluiten
   // executor.shutdown()
   

3. Coroutines (Kotlin Coroutines): Lichtgewicht threads beheerd door het framework, die asynchrone en niet-blokkerende uitvoering bieden. Ze zijn de voorkeursmethode in moderne Android-ontwikkeling.

   // Voeg de afhankelijkheden kotlinx-coroutines-core en kotlinx-coroutines-android toe
   
   import kotlinx.coroutines.*
   
   // Start een coroutine in de globale scope
   GlobalScope.launch {
       delay(1000L) // Niet-blokkerende vertraging
       println("Hallo vanaf de coroutine!")
   }
   
   // Voorbeeld van gebruik in een ViewModel (voor Android)
   /*
   import androidx.lifecycle.ViewModel
   import androidx.lifecycle.viewModelScope
   
   class MyViewModel : ViewModel() {
       fun doSomethingAsync() {
           viewModelScope.launch {
               // Code die binnen de scope van de ViewModel draait,
               // die automatisch wordt geannuleerd bij het opschonen van de ViewModel
           }
       }
   }
   */
   

Vergelijking van benaderingen:

Benadering	Beheer	Lichtgewicht	Foutafhandeling	Annulering	Gebruiksgemak (voor typische taken)
java.lang.Thread	Handmatig (aanmaken, starten, beheren)	Zwaar	Handmatig	Handmatig	Gemiddeld
java.util.concurrent	Via de API van executors	Zwaar	Via API	Via API	Gemiddeld
Coroutines (Kotlin Coroutines)	Framework (scopes, contexts, dispatchers)	Lichtgewicht	Gestructureerd	Ingebouwd	Laag (voor typische taken)

Coroutines bieden de meest handige en efficiënte manier om met asynchrone code te werken op Android, met minimale problemen met levenscyclusbeheer en annulering van taken.