Jak zaimplementować wielowątkowość w Kotlinie?

Wielowątkowość w Kotlinie można realizować na kilka sposobów:

1. Standardowe wątki Java (Threads):

   // Implementacja interfejsu Runnable
   class MyRunnable : Runnable {
       override fun run() {
           // Kod wykonywany w osobnym wątku
           println("Cześć z wątku: ${Thread.currentThread().name}")
       }
   }
   
   fun main() {
       // Tworzymy instancję Runnable
       val runnable = MyRunnable()
       // Tworzymy obiekt Thread z Runnable
       val thread = Thread(runnable)
       // Uruchamiamy wątek
       thread.start()
   }
   

   Lub z użyciem wyrażenia lambda:

   fun main() {
       val thread = Thread {
           // Kod wykonywany w osobnym wątku
           println("Cześć z wątku: ${Thread.currentThread().name}")
       }
       thread.start()
   }
   

2. Kotlin Coroutines: To zalecane i bardziej nowoczesne podejście w Kotlinie, zapewniające lekką wielowątkowość.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       // Tworzymy nową korutynę w zakresie globalnym
       launch {
           delay(1000L) // Nieblokujące opóźnienie 1 sekundy
           println("Cześć z korutyny")
       }
       // Główny wątek kontynuuje pracę
       println("Cześć z głównego wątku")
       // runBlocking oczekuje na zakończenie wszystkich korutyn potomnych
   }
   

   Przykłady różnych konstruktorów korutyn:

   • launch: Uruchamia nową korutynę bez wartości zwrotnej.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       launch {
           println("Ta korutyna po prostu wykonuje akcję")
       }
   }
   

   • async: Uruchamia nową korutynę zwracającą wynik za pomocą Deferred.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       val deferredResult = async {
           delay(1000L)
           "Wynik z korutyny"
       }
       val result = deferredResult.await() // Oczekiwanie na wynik
       println(result)
   }
   

3. RxKotlin/RxJava: Programowanie reaktywne pozwala również na pracę z operacjami asynchronicznymi i wielowątkowością, używając schedulerów (Schedulers).

   import io.reactivex.rxjava3.core.Observable
   import io.reactivex.rxjava3.schedulers.Schedulers
   
   fun main() {
       Observable.just("Element asynchroniczny")
           .subscribeOn(Schedulers.io()) // Subskrybować na wątku I/O
           .observeOn(Schedulers.computation()) // Obserwować wyniki na wątku obliczeniowym
           .subscribe { item ->
               println("Odebrano: $item na wątku ${Thread.currentThread().name}")
           }
   
       Thread.sleep(2000) // Czekać na zakończenie operacji asynchronicznych
   }
   

Wybór metody zależy od konkretnego zadania. Dla większości nowoczesnych aplikacji Kotlin preferowane są korutyny ze względu na ich lekkość, prostotę użycia i wbudowane wsparcie w języku. Wątki Java mogą być odpowiednie do bardziej niskopoziomowej kontroli, a biblioteki reaktywne do pracy z przepływami danych.