როგორ მუშაობს async/await კონსტრუქცია Kotlin პროგრამირების ენაში?

Kotlin-ში ასინქრონული პროგრამირებისათვის გამოიყენება კორუტინები, არა ჩვეულებრივი async/await, როგორც C# ან JavaScript-ში. თუმცა, kotlinx.coroutines ბიბლიოთეკა უზრუნველყოფს async და await ფუნქციებს, რომლებიც ახორციელებენ მსგავს პატერნს, დაფუძნებულს კორუტინებზე.

როგორ მუშაობს:

1. async: ეს არის ბილდერი ფუნქცია (CoroutineScope extension function), რომელიც იწყებს ახალ კორუტინას პარალელურად და აბრუნებს გადადებულ მნიშვნელობას Deferred<T> ტიპში. Deferred<T> არის თავისებური "მომავალი" შედეგი გამოთვლების, რომელიც ჯერ არ არის მზად. კოდის შესრულება async-ის შემდეგ განაგრძობს მაშინვე, არ დაელოდოს ასინქრონული ოპერაციის დასრულებას.

   // მაგალითი async-ის გამოყენებით
   val deferredResult = CoroutineScope(Dispatchers.IO).async {
       // ასინქრონული ოპერაცია (მაგალითად, სერვერის მოთხოვნა ან ფაილის კითხვა)
       delay(1000) // გრძელვადიანი სამუშაოს იმიტაცია
       "ასინქრონული ოპერაციის შედეგი"
   }
   

2. await: ეს არის suspend-ფუნქცია, რომელიც იძახება Deferred<T> ობიექტზე. იგი აჩერებს მიმდინარე კორუტინას მდე, სანამ ასინქრონული ოპერაცია, რომელიც async-ით დაიწყო, არ დასრულდება და შედეგი არ იქნება მზად. await აბრუნებს მზად შედეგს T ტიპში.

   // მაგალითი await-ის გამოყენებით
   // suspend ფუნქციის ან კორუტინაში
   val result = deferredResult.await() // აჩერებს შესრულებას შედეგის მიღებამდე
   println(result)
   

ძირითადი მახასიათებლები:

• კორუტინები: Kotlin-ის async/await-ის საფუძველში კორუტინებია. async ქმნის ახალ კორუტინას, ხოლო await აჩერებს მიმდინარე კორუტინას ბლოკირების გარეშე.
• Deferred<T>: ეს არის ანალოგი Promise-ს JavaScript-ში ან Task<T>-ს C#-ში. ის წარმოადგენს შედეგს, რომელიც მომავალში იქნება ხელმისაწვდომი. Deferred მემკვიდრეობს Job-დან, რაც საშუალებას აძლევს მართოთ ასინქრონული ოპერაციის ციკლი (გაუქმება, სტატუსის შემოწმება).
• ნებლოკინგი: await არ ბლოკავს იმ ნაკადს, რომელშიც კორუტინა ხორციელდება. ამის ნაცვლად, ის აჩერებს კორუტინას, გამოთავისუფლებით ნაკადს სხვა დავალებების შესრულებისთვის. როდესაც შედეგი მზად იქნება, კორუტინა განახლდება.
• Scope: როგორც async, ასევე launch (სხვა კორუტინის ბილდერი) არის CoroutineScope extension functions. ეს ნიშნავს, რომ ისინი უნდა შესრულდეს გარკვეულ საზღვრებში (Scope). Scope მართავს დაწყებული კორუტინების ციკლს.
• გამონაკლისების გადაცემა: კორუტინაში წარმოქმნილი გამონაკლისები შენახულია Deferred ობიექტში და გადმოაგდებს await-ის დროს.

შედარება launch-თან:

ასპექტი	launch	async
დაბრუნების ტიპი	Job	Deferred<T> (მემკვიდრე Job-ის)
მიზანი	"დაიწყე და დამთავრდა" (პარალელური ეფექტები)	შედეგის მიღება
ელოდება დასრულებას	არა (თუ არ გამოიყენება join())	კი (თუ გამოიყენება await())
გამოყენების მაგალითი	UI განახლების დაწყება	სერვერული მოთხოვნის შესრულება და პასუხის დამუშავება

async და await Kotlin-ში საშუალებას აძლევს დაწეროთ ასინქრონული კოდი სერიული სტილში, რაც მას უფრო წასაკითხს და გასაგებს ხდის, ამავდროულად იყენებს ნებლოკინგის უპირატესობებს.