Ինչպես իրականացնել բազմապատկման գործառույթը…

Կոտլինում բազմաթյանային ծրագրավորումը կարող է իրականացվել մի քանի եղանակներով:

Ստանդարտ 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()
}

Կամ օգտագործելով lambda արտահայտություն:

fun main() {
    val thread = Thread {
        // Կոդ, որը կիրականացվի առանձին թելում
        println("Բարև, թելից: ${Thread.currentThread().name}")
    }
    thread.start()
}

Kotlin Coroutines (Կորուտիններ): Սա առաջարկվող և ավելի ժամանակակից մոտեցում է Kotlin-ում, որը ապահովում է թեթև բազմաթյանային գործառույթներ:

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Ստեղծում է նոր կորուտին գլոբալ scope-ում
    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 թելերը կարող են կիրառվել ցածր մակարդակի վերահսկողության համար, իսկ ռեակտիվ գրադարանները՝ տվյալների հոսքերի աշխատանքի համար։

Ինչպես իրականացնել բազմապատկման գործառույթը Kotlin-ում?