Come implementare il multithreading in Kotlin?

La multitasking in Kotlin può essere implementata in diversi modi:

1. Thread Java standard (Threads):

   // Implementare l'interfaccia Runnable
   class MyRunnable : Runnable {
       override fun run() {
           // Codice che verrà eseguito in un thread separato
           println("Ciao dal thread: ${Thread.currentThread().name}")
       }
   }
   
   fun main() {
       // Creare un'istanza di Runnable
       val runnable = MyRunnable()
       // Creare un oggetto Thread con Runnable
       val thread = Thread(runnable)
       // Avviare il thread
       thread.start()
   }
   

   Oppure usando un'espressione lambda:

   fun main() {
       val thread = Thread {
           // Codice che verrà eseguito in un thread separato
           println("Ciao dal thread: ${Thread.currentThread().name}")
       }
       thread.start()
   }
   

2. Coroutines di Kotlin: È un approccio raccomandato e più moderno in Kotlin, che fornisce multitasking leggero.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       // Creare una nuova coroutine nello scope globale
       launch {
           delay(1000L) // Ritardo non bloccante di 1 secondo
           println("Ciao dalla coroutine")
       }
       // Il thread principale continua a lavorare
       println("Ciao dal thread principale")
       // runBlocking aspetta la fine di tutte le coroutine figlie
   }
   

   Esempi di diversi costruttori di coroutine:

   • launch: Avvia una nuova coroutine senza valore di ritorno.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       launch {
           println("Questa coroutine esegue semplicemente un'azione")
       }
   }
   

   • async: Avvia una nuova coroutine che restituisce un risultato usando Deferred.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       val deferredResult = async {
           delay(1000L)
           "Risultato dalla coroutine"
       }
       val result = deferredResult.await() // Attende il risultato
       println(result)
   }
   

3. RxKotlin/RxJava: La programmazione reattiva permette anche di lavorare con operazioni asincrone e multitasking, usando scheduler (Schedulers).

   import io.reactivex.rxjava3.core.Observable
   import io.reactivex.rxjava3.schedulers.Schedulers
   
   fun main() {
       Observable.just("Elemento asincrono")
           .subscribeOn(Schedulers.io()) // Iscriversi sul thread I/O
           .observeOn(Schedulers.computation()) // Osservare i risultati sul thread di calcolo
           .subscribe { item ->
               println("Ricevuto: $item sul thread ${Thread.currentThread().name}")
           }
   
       Thread.sleep(2000) // Attendere il completamento delle operazioni asincrone
   }
   

La scelta del metodo dipende dal compito specifico. Per la maggior parte delle applicazioni Kotlin moderne, le coroutines sono preferite per la loro leggerezza, facilità d'uso e supporto integrato nel linguaggio. I thread Java possono essere appropriati per un controllo di basso livello, e le librerie reattive per lavorare con flussi di dati.