Kaip Kotlin korutinos tvarko asinchroninį darbą Android?

Question

Accepted Answer

**Korutinos** yra Kotlin sprendimas **asinchroniniam programavimui** — rašyti asinchroninį kodą (tinklo užklausos, duomenų bazės operacijos), kuris skaitosi nuosekliai be pagrindinės gijos blokavimo. Tai modernus, rekomenduojamas būdas tvarkyti asinchroninį darbą Android, išvengiant grąžinimo sudėtingumo.

## Kodėl asinchroninis darbas svarbus Android

```text
The MAIN (UI) thread must stay responsive — blocking it (with network/DB work) freezes
the UI (ANR "Application Not Responding" errors):
  → long operations MUST run off the main thread (asynchronously)
  → old approaches: callbacks (nested, complex), threads/AsyncTask (verbose, error-prone)
→ COROUTINES make async code clean and sequential.
```

## Korutinos: nuoseklus asinchroninis kodas

```kotlin
// suspend functions can pause without blocking the thread
suspend fun loadUser(): User {
  val user = api.getUser()        // suspends here (async network call), doesn't BLOCK
  val posts = api.getPosts(user)   // then this runs — reads sequentially!
  return user
}

// launch a coroutine (e.g. in a ViewModel)
viewModelScope.launch {
  val user = loadUser()            // async work
  updateUi(user)                    // back on the main thread, update UI
}
```

`suspend` funkcijos gali sustoti (ties `await` panašiais taškais) be gijos blokavimo, leidžiant asinchroniniam kodui skaitytis iš viršaus į apačią kaip sinchroninis kodas — daug švariau nei grąžinimai.

## Pagrindinės sąvokos

```text
SUSPEND functions → can pause/resume without blocking
COROUTINE SCOPES → viewModelScope, lifecycleScope → tie coroutines to lifecycle (auto-cancel)
DISPATCHERS → which thread: Dispatchers.Main (UI), .IO (network/disk), .Default (CPU)
Structured concurrency → coroutines are scoped, cancellable, and managed (no leaks)
Flow → asynchronous streams of values (reactive data over time)
```

## Kodėl tai svarbu

Supraști korutinas yra būtina, nes **Android programos nuolat atlieka asinchroninį darbą** (tinklo užklausos, duomenų bazės prieiga), o korutinos yra modernus, rekomenduojamas būdas tai tvarkyti, todėl tai neišvengiama šiuolaikinio Android žinojimo dalis.

Pagrindinė apribojimas — **pagrindinė/UI gija turi likti patvari**, todėl ilgos operacijos (tinklas, duomenų bazė, sunki skaičiavimas) turi veikti **ne pagrindinėje gijoje**, kad nesustabdytų UI (iššaukdamos ANR klaidas) — todėl asinchroninis programavimas yra būtinas praktiškai kiekvienos programos atveju.

Korutinos tai sprendžia elegantiš­kai: **suspend funkcijos gali sustoti be gijos blokavimo**, leidžiant asinchroniniam kodui **skaitytis nuosekliai** (iš viršaus į apačią kaip sinchroninis kodas), o ne kaip įdėtos grąžinimo funkcijos — didelis pagerinti­mas lyginant su senais metodais (grąžinimai, kurie įsideda į sudėtingumą, arba šiurkštūs klaidos linkę siūlai/AsyncTask).

Supraští **pagrindines sąvokas** — suspend funkcijos (sustojimas be blokavimo), **korutinų sritys** (viewModelScope, lifecycleScope, kurie susieja korutinas su gyvavimo ciklu ir automatiškai jas atšaukia, prevenuo­jant nutekėjimus — svarbu teisingumui), **dispečeriai** (gijos pasirinkimas: Main UI, IO tinklui/diskui, Default CPU darbui), struktūrizuota paralelizacija (sritimi apribota, atšaukiama, nutekėjimu laisva korutinos), ir **Flow** (asinchroniniai srautai reaktyvūs duomenims) — yra būtina asinchroniniam darbui teisingai tvarkyti šiuolaikiniame Android.

Korutinos dabar yra standartinis, rekomenduojamas metodas (integruotas su Jetpack bibliotekomis, ViewModels ir Room), todėl jos yra būtinos dabartiniam Android kūrimui.

Kadangi asinchroninis darbas yra visuotin­is Android (tinklas, duomenų bazė — ir turi veikti ne pagrindinėje gijoje, kad UI liktų patvari) ir korutinos yra modernus, rekomenduojamas, daug švarbesnis sprendimas, ir kadangi jas suprasti (suspend funkcijos, sritys, dispečeriai, struktūrizuota paralelizacija) yra būtina teisingam asinchroniniam darbui šiuolaikinėse programose, Kotlin korutinų supratimas yra būtina, dažnai taikoma šiuolaikinio Android žinojimo dalis — standartinis būdas tvarkyti asinchroninį darbą, kurio praktiškai kiekviena Android programa reikalau­ja, būtinas programų patvaru­mui išlaiky­ti atliekant tinklo ir duomenų bazės operacijas švariai.