Jak pracujesz z wielowątkowością w Kotlin?

W Kotlinie, do pracy z wielowątkowością, głównie używam korutyn. Zapewniają one bardziej lekki i elastyczny sposób w porównaniu do tradycyjnych wątków, minimalizując narzut i upraszczając zarządzanie operacjami równoległymi.

Kluczowe koncepcje przy pracy z korutynami:

• Funkcje Suspend: Funkcje, które mogą być zawieszone i wznowione. Stanowią podstawę dla operacji asynchronicznych w korutynach.

  suspend fun fetchData(): String {
      delay(1000) // Przykład zawieszenia
      return "Dane otrzymane"
  }
  

• CoroutineScope: Określa cykl życia korutyn i pozwala na zarządzanie ich anulowaniem.

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // CoroutineScope dla blokującego wykonania
      launch { // Tworzenie nowej korutyny w tym Scope
          // Kod korutyny
      }
  }
  

• Dispatchers (Dyspozytory): Określają pulę wątków, na której będzie wykonywana korutyna.
  • Dispatchers.Default: Dla intensywnych obliczeń CPU.
  • Dispatchers.IO: Dla blokujących operacji I/O (np. praca z siecią, plikami).
  • Dispatchers.Main: Do pracy z UI (dostępne na odpowiednich platformach, np. Android).
  • Dispatchers.Unconfined: Nie jest związany z określoną pulą wątków.

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // Przełączenie na dyspozytor I/O
          // Wykonanie operacji blokującej
      }
  }
  

• Budowniczy korutyn (Coroutine Builders): Funkcje do uruchamiania korutyn.
  • launch: Uruchamia korutynę i zwraca Job, który można użyć do jej anulowania.
  • async: Uruchamia korutynę i zwraca Deferred, który pozwala na uzyskanie wyniku za pomocą await().

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Zadanie równoległe
      }
  
      val deferredResult = async {
          // Zadanie zwracające wynik
          "Wynik"
      }
  
      job.cancel() // Anuluj zadanie
      val result = deferredResult.await() // Uzyskaj wynik
  }
  

Aby synchronizować dostęp do zasobów współdzielonych, używam narzędzi z pakietu kotlinx.coroutines.sync, takich jak Mutex lub Semaphore.

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Zablokuj Mutex przed dostępem do zasobu wspólnego
        counter++
    }
}

W niektórych specyficznych przypadkach, gdy wymagana jest bezpośrednia kontrola nad wątkami na niskim poziomie, mogę używać klas z pakietu java.util.concurrent lub bezpośrednio klas Thread i Runnable, choć jest to znacznie rzadsze niż korutyny.

Zalety korutyn w porównaniu do tradycyjnych wątków:

Cecha	Korutyny	Tradycyjne wątki
Lekkość	Lekkie, wiele na jednym wątku	Ciężkie, każdy wątek zajmuje zasoby
Przełączanie	Kooperatywne (suspend/resume)	Wymuszone (planista OS)
Anulowanie	Łatwe i strukturalne	Trudne, wymaga obsługi przerwań
Debugowanie	Wygodne, śledzenie stosu jest zachowane	Może być trudne
Struktura	Obsługują strukturalną konkurencję	Mniej strukturalne

Preferuję korutyny ze względu na ich wydajność, prostotę pisania kodu asynchronicznego i lepszą czytelność, szczególnie przy pracy z złożonymi sekwencjami operacji asynchronicznych.