Какви елементи за многозадачност предоставя Kotlin…

Котлин предоставя следните елементи за многопоточност:

Корутии: Леките нишки, базирани на паузиращи функции. Осигуряват асинхронно и неблокиращо изпълнение на кода.

Конструктори на корутини: Функции, които стартират корутини. Основни: 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: Функция-строител на корутина, която блокира текущата нишка до завършването на корутината. Използва се за обединяване на блокиращ и неблокиращ код, често в тестове или главни функции.
```
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 - "горещ" поток за широковещателна разпространение на данни.

Какви елементи за многозадачност предоставя Kotlin?