Ինչպես կարգավորել և օգտագործել կորուտինները Kotlin նախագծերում?

Կորուտինների կարգավորումը պահանջում է համապատասխան կախվածությունը ավելացնել build.gradle ֆայլում:

// build.gradle (հավելվածի մոդուլ)
dependencies {
    //... այլ կախվածություններ
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3") // JVM, Android, JS, Native համար
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3") // Android համար (եթե անհրաժեշտ է Dispatchers.Main)
}

Կորուտինների օգտագործումը ներառում է՝

1. Կյանքի շրջանը (Scope): Կարգավորում է այն տարածքը, որտեղ կորուտինները կիրականանան և կառավարվեն իրենց կյանքի ցիկլով:

   • GlobalScope: Բոլոր հավելվածի համար, օգտագործել զգուշությամբ, քանի որ հնարավոր է հիշողության լքման ռիսկ:
   • CoroutineScope: Հստակորեն ստեղծված, թույլ է տալիս վերահսկել չեղարկումը:
   • Նախաձեռնված տարածքներ ֆրեյմվորկներում (օրինակ, lifecycleScope Android ViewModel-ում):

   // Օրինակ CoroutineScope-ով
   val myScope = CoroutineScope(Dispatchers.Default + SupervisorJob()) // Ստեղծում է Scope-ով Dispatcher և Job
   
   fun performBackgroundTask() {
       myScope.launch { // Կորուտին սկսում է
           // Երկարատև հաշվարկային պրոցես
       }
   }
   
   fun cancelAllTasks() {
       myScope.cancel() // Չեղարկում է բոլոր կորուտինները Scope-ով
   }
   

2. Կորուտինների ստեղծողներ (Builders): Ֆունկցիաներ կորուտինների սկսելու համար:

   • launch: Սկսում է կորուտին, որը չի վերադարձնում արդյունք հստակ (վերադարձնում է Job):
   • async: Սկսում է կորուտին, որը վերադարձնում է արդյունք Deferred տեսքով:

   import kotlinx.coroutines.*
   
   suspend fun fetchData() = coroutineScope { // coroutineScope - կառուցող կառուցվածքային համաժամանակության համար
       val data1 = async { networkCall1() } // async վերադարձնում է Deferred
       val data2 = async { networkCall2() }
   
       // ... տվյալների մշակումը հետո
       data1.await() // Արդյունքի ստացում Deferred-ից, սինխրոնիզացիա
       data2.await()
   }
   
   suspend fun networkCall1(): String {
       delay(1000) // Նմանացնող ցանցային հարցում
       return "Data 1"
   }
   
   suspend fun networkCall2(): String {
       delay(1500)
       return "Data 2"
   }
   
   fun startFetching() = runBlocking { // runBlocking - կառուցող, որը բլոկավորում է ընթացիկ հոսքը
       launch { // launch վերադարձնում է Job
           println("Fetching data...")
           fetchData()
           println("Data fetched!")
       }
   }
   

3. Դիսպետչերներ (Dispatchers): Կարգավորում են, թե որ հոսքում կամ հոսքերի խմբում կիրականանա կորուտինը:

   • Dispatchers.Default: CPU-համառ աշխատանքների համար
   • Dispatchers.IO: Բլոկավորող I/O գործողությունների համար
   • Dispatchers.Main: Հիմնական հոսք (միայն Android և Swing/JavaFX)
   • Dispatchers.Unconfined: Կորուտինը սկսվում է կանչող հոսքում, հետո սինխրոնիզացվում է այլ հոսքում:

   import kotlinx.coroutines.*
   
   fun simpleTask() {
       GlobalScope.launch(Dispatchers.IO) { // Դիսպետչեր նշելով
           // I/O գործողություն
           println("Running on thread: ${Thread.currentThread().name}")
       }
   }
   
   fun main() = runBlocking {
       launch(Dispatchers.Default) {
           println("Default thread: ${Thread.currentThread().name}")
       }
       launch(Dispatchers.Unconfined) {
            println("Unconfined thread 1: ${Thread.currentThread().name}")
            delay(100) // Սպասում
            println("Unconfined thread 2: ${Thread.currentThread().name}") // Վերականգնում այլ հոսքում
       }
       delay(200) // Սպասում կորուտինների ավարտին
   }
   

4. Հետաձգող ֆունկցիաներ (Suspending functions): Ֆունկցիաներ, որոնք նշված են suspend-ով, կարող են հետաձգվել և վերսկսվել առանց հոսքի բլոկավորման:

5. Չեղարկում և արտահայտությունների մշակումը: Կորուտինները աջակցում են կառուցվածքային չեղարկում և արտահայտությունների տարածում:

   • Չեղարկում:

     import kotlinx.coroutines.*
     
     fun cancellableTask() = GlobalScope.launch {
         try {
             repeat(1000) { i ->
                 println("Working $i ...")
                 delay(100) // հետաձգող ֆունկցիա, որը հարգում է չեղարկումը
             }
         } catch (e: CancellationException) {
             println("Task was cancelled!")
         } finally {
             println("Cleaning up...")
         }
     }
     
     fun main() = runBlocking {
         val job = cancellableTask()
         delay(500) // Կարճ ժամանակ սպասում
         job.cancelAndJoin() // Չեղարկում և սպասում ավարտին
     }
     

   • Արտահայտություններ: launch-ով չեղարկված արտահայտությունը կհանգեցնի ծրագրի անկմանը (Android-ում՝ ըստ նախնական կարգավորումների): async-ով՝ արտահայտությունը կբռնվի await()-ի ժամանակ:

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       val handler = CoroutineExceptionHandler { _, exception ->
           println("Caught exception: $exception")
       }
   
       val job = GlobalScope.launch(handler) { // Օգտագործելով handler
           throw IllegalStateException("Something went wrong")
       }
       job.join() // Սպասում ավարտին
   }