آموزش جامع کروتنیز (Coroutines) در کاتلین به همراه مثال

تعریف کروتینز

کروتینز (Coroutines) یک کتابخونه ی مدرن چندنخی در کاتلین است که با چندنخی در جاوا طراحی شده، با کروتنیز در کاتلین کد ها میتونن به صورت زنجیره وار نوشته بشن و به صورت همزمان اجرا بشن.

در Thread برای ایجاد هر کاری باید یک Thread ایجاد کنیم اما در کروتینز، چند کروتین میتونن از یک Thread استفاده کنن و این ویژگی باعث میشه نخ های کمتری ایجاد بشه و باعث بهینه تر شدن برنامه میشه.

فرض کنید دو کروتین داریم و یک نخ؛ کروتین اول توسط نخ اجرا میشه، زمانی که کار کروتین اول تموم بشه یا به صورت موقت معلق بشه از نخ خارج شده و کروتین دوم توسط نخ اجرا میشه.

در زیر عملکرد کروتین با Thread مقایسه شده است.

افزودن کروتینز به پروژه

برای اضافه کردن کروتینز به پروژه کافیه در فایل build.gradle به صورت زیر اضافه و سپس پروژه رو سینک کنید.

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:version")    
    //implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:version")
    //Other dependencies
}
          

اگه بخوایم از کروتینز در اندروید استفاده کنیم علاوه بر kotlinx-coroutines-core باید kotlinx-coroutines-android رو هم از کامنت در بیاریم.

کلیدواژه suspend

با استفاده از کلیدواژه suspend میتونیم یک تابع تعلیق پذیر (suspend function) تعریف کنیم، تابع ساسپند میتونه به صورت موقت متوقف بشه و سپس ادامه پیدا کنه؛ توابع ساسپند فقط داخل کروتین یا داخل تابع ساسپند دیگه قابل صدا زدن هستن.

فرم کلی

suspend fun mySuspendFunction(){
  //Execute codes here
}
          

یکی از راه های صدا زدن توابع ساسپند داخل تابع main، تعریف تابع main به عنوان تابع ساسپند است.

suspend fun main(){
  //start point
  mySuspendFunction()
}

suspend fun mySuspendFunction(){
  println("Hello from suspend function!")
}
          

محدوده کروتین

برای کروتین هایی که ایجاد میکنیم باید محدوده تعیین کنیم، برای ایجاد محدوده یکی از توابع coroutineScope یا CoroutineScope رو صدا میزنیم.

با محدوده ی کروتین چرخه ی حیاط (lifecycle) کروتین ها رو مدیریت میکنیم.

suspend fun mySuspendFunction(){
  val scope = coroutineScope{
    //scope.launch{}
  }
}
            

fun myFunction(){
  val scope = CoroutineScope(context)
  //scope.launch{}
}
            

بیلدر (Builder) ها و ایجاد کروتین با بیلدر (Builder) ها

با استفاده از توابع launch, async و runBlocking میتونیم کروتین جدید ایجاد کنیم؛ این سه تابع به علاوه تابع withContext که در قسمت های بعدی این مطلب بهش می پردازیم به بیلدر (Builder) معروف هستن.

val job: Job = launch{
  //Execute codes here
}
              

val deferred: Deferred<T> = async{  

  val r: R = ...
  
  return@async r
}

val result: R = deferred.await()
              

val scope = CoroutineScope(context)

scope.launch{
  //Execute codes here
}

scope.async{
  //Execute codes here
}          

coroutineScope{
  launch{
    //Execute codes here
  }

  async{
    //Execute codes here
  }
}
              

coroutineScope{
  launch{
    //Execute codes in outer coroutine
    val deferred = async{
      //Execute codes inside async
    }
  }
}
              

fun main() = runBlocking{
  //Execute codes here
}
          

در مثال زیر میخوایم برنامه n بار یک کاراکتر رو نمایش بده.

fun printChars(char: Char, numberOfChars: Int){
  
  val scope = CoroutineScope(Dispatchers.Default)

  scope.launch {

    println("Printing $numberOfChars $char: ")

    for (i in 0 until numberOfChars) {
        if (i % 10 == 0) println()
          print(char)
        }
        println()
    }
}            
          

در مثال زیر میخوایم برنامه اعداد یک تا n رو نمایش بده.

fun printNumbers(n: Int){

    val scope = CoroutineScope(Dispatchers.Default)

    scope.launch {

        for (i in 1..n){
            if (i % 10 == 0) println()
            print("$i ")
        }

    }
}
          

صدا زدن دو تابع printNumbers و printChars

fun main() {
  printChars()
  printNumbers()
}
          

در مثال زیر برنامه یک متن چاپ می کنه و با تابع async حاصل جمع اعداد 1 تا 100 رو نمایش میده و در نهایت پیغام آخر رو چاپ می کنه.

suspend fun main(){
  helloAndSum()
}

suspend fun helloAndSum(){
  println("Hello from suspend function!")

  val result = coroutineScope{
    val deferred = async{

      var sum = 0

      for(i in 1 .. 100){
        sum += i
      }

      return@async sum
    }

    val asyncResult = deferred.await()

    asyncResult
  }

  println("Sum of 1 to 100 is $result")

  println("Goodbye!")
}
          

در زیر میخوایم اعداد یک تا 100 رو نمایش بدیم و زمانی که عدد بر 10 بخش پذیر باشه جمع اعداد یک تا اون عدد رو با async محاسبه کنیم.

suspend fun printNumbersAndSumDivisibleOfTens(){

    for (i in 1 .. 100){

        print("$i ")

        if (i % 10 == 0){

            println()

           val sum = coroutineScope {
                val deferred: Deferred = async {
                    var sum = 0

                    for (k in 1..i) {
                        sum += k
                    }

                    return@async sum
                }

                val sum = deferred.await()

                sum
            }
            
            println("1-$i sum:  $sum")
        }
    }
}
              

کروتین های تودرتو

داخل هر Coroutine میتونیم یک کروتین جدید ایجاد کنیم؛ به کروتین هایی که داخل یک کروتین دیگه ایجاد میشن، کروتین فرزند (child) و به کروتینی که داخلش ایجاد شدن کروتین parent میگیم.

برای ایجاد کروتین جدید داخل یک کروتین دیگه نیازی به تعریف CoroutineScope نداریم.

val scope = CoroutineScope(context)

scope.launch{

  launch{
    
    //Execute codes here

    launch{
      //Execute codes here
    }

  }

  launch{
    //Execute codes here
  }
  
}
            

بررسی کانتکست (Context)

برای هر CoroutineScope و بیلدر (Builder) یک Context وجود داره.

کانتکست (Context) در کروتین چهار ويژگی داره که عبارتند از Dispatcher, Job, CoroutineName و CoroutineExceptionHandler؛ برای ایجاد کانتکست در کروتین میتونیم یک دو یا هر چهار ويژگی رو با علامت اختصاصی + تعریف کنیم.

بجز Job تمام ویژگی های context به صورت پیشفرض از parent به child می رسه مگه اینکه بخوایم تغییرشون بدیم.

val context = Dispatchers.Default + Job() + CoroutineName("my-coroutine") + CoroutineExceptionHandler {context, throwable -> }

val scope = CoroutineScope(context)
scope.launch{

}
          

val context = Dispatchers.Default
val scope = CoroutineScope(context)
scope.launch{

}
              

val context = Dispatchers.IO
val scope = CoroutineScope(context)
              

fun main() = runBlocking{
  coroutineScope{
    launch(Disptachers.Unconfined){
      println("Unconfined: Running on ${Thread.currentThread().name}")
      delay(100L)
      println("Unconfined: Running on ${Thread.currentThread().name}")
    }
  }
}
              

@OptIn(DelicateCoroutinesApi::class, ExperimentalCoroutinesApi::class)
val Dispatchers.myDispatcher: CoroutineDispatcher
    get() = newSingleThreadContext("myThread")

val context = Disptachers.myDisptacher

val scope = CoroutineScope(context)

scope.launch{
  
  //Execute codes here

  launch(Disptachers.Default){

  } 

}
              

val scope = CoroutineScope(Disptachers.Default)
scope.launch{
  //Execute codes in parent
  launch{
    //Execute codes in child
  }
}
            

val scope = CoroutineScope(Dispatchers.Default)

val parent: Job = Job()

scope.launch(parent){
  //Execute codes in parent
  val child: Job = Job(parent)
  launch(child){
    //Execute codes in child
  }
}
            

val scope = CoroutineScope(Dispatchers.Default)

val parent: Job = Job()
              
scope.launch(parent){
  //Execute codes in parent
  val child: Job = Job()
  launch(child){
    //Execute codes in child
  }
}
            

val context = Dispatchers.Default + CoroutineName("my-coroutine-with-Dispatchers.Default")
val scope = CoroutineScope(context)
            

val context = Dispatchers.Default + CoroutineName("my-coroutine") + CoroutineExceptionHandler{context, throwable -> /*Handle Exception here*/}

val scope = CoroutineScope(context)

//continue...
            

تابع withContext

با استفاده از تابع withContext می‌تونیم بدون ایجاد کروتین جدید کانتکست (Context) کروتین فعلی رو تغییر بدیم و پس از انجام کار به کروتین فعلی برگردیم.

تابع withContext یک تابع suspend است و باید داخل کروتین یا تابع suspend صدا زده بشه.

با تابع withContext میتونیم یک مقدار از نوع R رو برگردونیم.

در مثال زیر ابتدا اولین پیغام تابع چاپ میشه و سپس با withContext کانتکست عوض میشه و پیغام داخل withContext چاپ میشه و در نهایت به کانتکست کروتین اصلی بر میگردیم و پیام اخر چاپ میشه.

suspend fun testWithContext(){

    println("Before calling withContext...")

    val result: String = withContext(Dispatchers.Default){

        println("Executing codes in withContext...")

        return@withContext "done"
    }


    println("withContext operation is $result")

    println("After calling withContext...")
}
          

خلاصه

• کروتینز یک کتابخونه ی مدرن است که توسط کاتلین و با چندنخی در جاوا ایجاد شده
• یک نخ میتونه چند کروتین رو اجرا کنه و به همین علت کروتین بهینه تر از چندنخی است.
• برای ایجاد کروتین ابتدا باید محدوده کروتین رو تعریف کنیم و سپس کروتین ایجاد کنیم.
• میتونیم با استفاده از سه تابع launch, async و runBlocking کروتین ایجاد کنیم.
• میتونیم داخل یک کروتین، کروتین دیگه ای ایجاد کنیم و به هرکدوم به ترتیب Parent و Child میگیم.
• هر کروتین یک کانتکست داره و هر کانتکست چهار ویژگی رایج داره که عبارتند از Disptachers, Job, CoroutineName و CoroutineExceptionHandler
• با استفاده از کلیدواژه suspend میتونیم یک تابع ساسپند ایجاد کنیم.
• تابع ساسپند میتونه به صورت موقت متوقف بشه و سپس ادامه پیدا کنه.
• با استفاده از withContext میتونیم بدون نیاز به ایجاد کروتین جدید، کانتکست کروتین فعلی رو تغییر بدیم و بعد از اتمام کار تابع به کروتین فعلی برگردیم.