Ի՞նչ բազմաֆունկցիոնալ տարրեր է տրամադրում Kotlin-ը։

Կոտլինը տրամադրում է հետևյալ բազմապատկման տարրերը:

• Կորուտիններ: Հ Lightweight հոսքեր, հիմնված կանգնեցվող ֆունկցիաների վրա: ապահովում են ասինխրոն և ոչ բլոկային կոդի կատարմամբ:
• Կորուտինների կառուցապատողներ: Ֆունկցիաներ, որոնք սկսում են կորուտիններ: հիմնականները՝ launch (սկսում է կորուտին առանց արժեք վերադարձնելու), async (սկսում է կորուտին և վերադարձնում Deferred, որը կարելի է սպասել արդյունքի համար):

  // Օրինակ `launch` օգտագործման
  GlobalScope.launch {
      println("Բարև կորուտինից ${Thread.currentThread().name}")
  }
  
  // Օրինակ `async` օգտագործման
  val deferred = GlobalScope.async {
      delay(1000) // Դիտարկում երկարատև օպերացիա
      "Արդյունք"
  }
  val result = runBlocking { deferred.await() } // Ապահովում արդյունքը
  

• Dispatchers: Հորոշում է, թե որ հոսքի պուլում է կատարվում կորուտինը: հիմնականները՝
  • Dispatchers.Default: Ընդհանուր հոսքի պուլ՝ CPU-հետաքրքրական առաջադրանքների համար:
  • Dispatchers.IO: Հոսքի պուլ՝ բլոկավորող մուտք/ելք գործողությունների համար (ֆայլեր, ցանց):
  • Dispatchers.Main: Դիսպետչեր՝ օգտագործողի ինտերֆեյսի հոսքի համար համապատասխան հարթակներում (Android, Swing):
  • Dispatchers.Unconfined: Կորուտինն սկսվում է ընթացիկ հոսքում, բայց կարող է վերականգնվել ցանկացած հոսքում:

  GlobalScope.launch(Dispatchers.IO) {
      // Կատարման մուտք/ելք
  }
  

• runBlocking: Կորուտինի կառուցապատող ֆունկցիա, որը բլոկավորում է ընթացիկ հոսքը մինչև կորուտինի ավարտը: Օգտագործվում է բլոկավոր և ոչ բլոկավոր կոդի միացման համար, հաճախ թեստերում կամ main-ֆունկցիաներում:

  runBlocking {
      launch {
          delay(500)
          println("Ավարտվեց ${Thread.currentThread().name}")
      }
      println("Սկսվեց ${Thread.currentThread().name}")
  }
  

• suspend ֆունկցիաներ: Ֆունկցիաներ, որոնց կատարմանը կարող է կանգնեցնել և վերականգնել: Կարող են կանչվել միայն այլ suspend ֆունկցիաներից կամ կորուտինների կառուցապատողներից:

  suspend fun doSomething() {
      delay(100) // Դիտարկում կանգնեցում
  }
  

• Job: Հենդլ սկսված կորուտինին: Առաջարկում է մեթոդներ կորուտինի կյանքի ցիկլը կառավարելու համար (եղարկում, սպասում ավարտին):

  val job = GlobalScope.launch {
     // Երկարատև օպերացիա
  }
  job.cancel() // Եղարկում կորուտինը
  runBlocking { job.join() } // Սպասում ավարտին
  

• CoroutineScope: Հորոշում է կորուտինների տեսադաշտը: Կորուտիններ, որոնք սկսվում են որոշ տեսադաշտում, ավտոմատ կերպով են չեղարկվում տեսադաշտի չեղարկման ժամանակ: Օգնում է կառավարել կորուտինների կյանքի ցիկլը:

  val scope = CoroutineScope(Dispatchers.Default)
  scope.launch {
      // Կորուտին այս տեսադաշտում
  }
  scope.cancel() // Չեղարկում բոլոր կորուտինները այս տեսադաշտում
  

• Կանալներ (Channel): Անվտանգ տվյալների փոխանցման պրիմիտիվներ կորուտինների միջև: Կանալները կարող են լինել միակողմանի (ուղարկում կամ ստացում միայն) կամ երկկողմանի:

  import kotlinx.coroutines.channels.Channel
  
  val channel = Channel<Int>()
  
  runBlocking {
      launch {
          for (x in 1..5) channel.send(x * x)
          channel.close() // Կարևոր է փակել կանալը
      }
      launch {
          for (y in channel) println(y)
      }
  }
  

• Մյուտեքսներ (Mutex): Սինխրոնիզացիայի պրիմիտիվներ՝ ընդհանուր ռեսուրսին բացառիկ մուտք ապահովելու համար: Հաստատում է հոսքի անվտանգություն՝ թույլ տալով միայն մեկ կորուտինին միաժամանակ տիրապետել մյուտեքսին:

  import kotlinx.coroutines.sync.Mutex
  import kotlinx.coroutines.sync.withLock
  
  val mutex = Mutex()
  var counter = 0
  
  suspend fun incrementCounter() {
      mutex.withLock {
          counter++
      }
  }
  

• Կարգավիճակներ (StateFlow, SharedFlow): Դատարկ տվյալների հոսքեր՝ ռեակտիվ ծրագրավորման և բազմահոսքային կոնտեքստում: StateFlow ներկայացնում է "մթնոլորտային" հոսք՝ ներկայիս վիճակով, իսկ SharedFlow՝ "տաք" հոսք՝ տվյալների լայնարձակ տարածման համար։