Какви възможности предоставя Kotlin за работа с…

Kotlin предоставя корутини (coroutines) за опростяване на асинхронните операции, предлагайки леки потоци, които не блокират основния поток на изпълнение.

Основни възможности:

Функции за спиране: Функции с ключовата дума suspend, които могат да бъдат спирани и възобновявани. Те не блокират нишката, в която се изпълняват.
```
suspend fun fetchData(): String {
    delay(1000) // Имитираме дълга операция
    return "Данните са получени"
}
```
Конструктори на корутини: Функции, използвани за стартиране на корутини:
- launch: Стартира нова корутина и връща Job (без блокиране).
```
GlobalScope.launch {
    println("Започната е корутина")
}
```
- async: Стартира нова корутина и връща Deferred<T> (блокира при извикване .await()).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // Изчаква резултата
```
- runBlocking: Блокира текущия поток до завършване на корутината (използва се главно като мост между блокиращ и неблокиращ код, например в тестове).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
CoroutineContext: Комплект от елементи, които определят поведението на корутината, включително Dispatcher и Job.
- Dispatcher: Определя нишката или пул от нишки, където се изпълнява корутината.
Dispatchers: Вградени обекти за управление на нишки:
- Dispatchers.Default: Общ пул от нишки за фонови операции.
- Dispatchers.IO: Оптимизиран за входно/изходни операции (дискови, мрежови операции).
- Dispatchers.Main: Главният UI поток (за Android, JavaFX и др.).
- Dispatchers.Unconfined: Стартира корутината в текущия поток, но след спиране може да продължи в който и да е поток.
```
GlobalScope.launch(Dispatchers.IO) {
    // Изпълнява се във входно/изходния поток
}
```
Структурирана конкуренция: Принцип, при който корутините имат родител (CoroutineScope) и се отменят автоматично при отменяне на родителя. Предотвратява течове на ресурси и улеснява управлението на жизнения цикъл.
```
// CoroutineScope автоматично управлява дъщерните корутини
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// При отменяне на scope, всички дъщерни корутини се отменят
scope.cancel()
```
Канали: Канали за безопасен пренос на данни между корутините. Могат да бъдат:
- Unbuffered: Получаването се извършва само след изпращане.
- Buffered: Позволява изпращане на няколко елемента преди блокиране.
- Conflated: Запазва само последния изпратен елемент.
```
val channel = Channel<Int>()

scope.launch {
    for (x in 1..5) channel.send(x)
    channel.close()
}

scope.launch {
    for (y in channel) println(y)
}
```

Flow: Поток от данни, който може да излъчва няколко стойности асинхронно. Подобен е на RxJava Observable, но е по-лек и интегриран с корутините.

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i) // Изпращане на стойност
    }
}

runBlocking {
    simpleFlow().collect { value -> println(value) } // Консумиране на стойностите
}

Тези възможности позволяват писане на асинхронен код в императивен стил, правейки го по-четим и поддържан в сравнение с използването на callback-и или Future.

Какви възможности предоставя Kotlin за работа с асинхронни операции?