Как да реализираме многопоточност в Kotlin?

Многопоточността в Kotlin може да бъде реализирана по няколко начина:

Стандартни Java нишки (Threads):

// Реализиране на интерфейса Runnable
class MyRunnable : Runnable {
    override fun run() {
        // Код, който ще се изпълнява в отделна нишка
        println("Здравей от нишката: ${Thread.currentThread().name}")
    }
}

fun main() {
    // Създаване на екземпляр на Runnable
    val runnable = MyRunnable()
    // Създаване на обект Thread с Runnable
    val thread = Thread(runnable)
    // Стартиране на нишката
    thread.start()
}

Или с използване на лямбда израз:

fun main() {
    val thread = Thread {
        // Код, който ще се изпълнява в отделна нишка
        println("Здравей от нишката: ${Thread.currentThread().name}")
    }
    thread.start()
}

Kotlin Coroutines (Корутини): Това е препоръчваният и по-съвременен подход в Kotlin, който предоставя леко нишково изпълнение.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Създаване на нова корутина в глобалната област
    launch {
        delay(1000L) // Не блокиращо забавяне за 1 секунда
        println("Здравей от корутината")
    }
    // Основният поток продължава
    println("Здравей от основния поток")
    // runBlocking очаква завършването на всички вложени корутини
}

Примери за използване на различни строители на корутини:

launch: Стартира нова корутина без връщане на стойност.

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Тази корутина просто изпълнява действие")
    }
}

async: Стартира нова корутина, която връща резултат чрез Deferred.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredResult = async {
        delay(1000L)
        "Резултат от корутината"
    }
    val result = deferredResult.await() // Изчакване на резултата
    println(result)
}

RxKotlin/RxJava: Реактивното програмиране също позволява работа с асинхронни операции и многопоточност, използвайки планировчици (Schedulers).

import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.schedulers.Schedulers

fun main() {
    Observable.just("Асинхронен елемент")
        .subscribeOn(Schedulers.io()) // Изпълнение на абонамента в I/O нишка
        .observeOn(Schedulers.computation()) // Наблюдаване на резултатите в изчислителна нишка
        .subscribe { item ->
            println("Получено: $item на нишката ${Thread.currentThread().name}")
        }

    Thread.sleep(2000) // Изчакване за завършване на асинхронните операции
}

Изборът на метод зависи от конкретната задача. За повечето съвременни Kotlin приложения, корутините са предпочитани поради тяхната лекота, простота на използване и вградена поддръжка в езика. Java нишките могат да бъдат подходящи за по-ниско ниво контрол, а реактивните библиотеки - за работа с потоци от данни.