Future/Promise — bu nima, asinxron hisoblashlar va dasturlash

Future/Promise nima?

Future/Promise — asinxron natijani ikki rolga ajratuvchi o'zaro bog'liq ob'ektlar juftligi. Promise natijani (resolve) yoki xatoni (reject) yozishi mumkin. Future uni faqat o'qiy oladi — callback (then, catchError) yoki await orqali. Bunday bo'linish iste'molchining natijani o'zgartira olmasligini, faqat undan foydalanishini kafolatlaydi.

Dart da Future

Dart tili Future ni asosiy asinxron mexanizm sifatida ishlatadi. Future<T> — kelajakda T turidagi qiymatni olish uchun kontrakt. Future uch holatdan birida bo'lishi mumkin: unresolved (operatsiya bajarilmoqda), resolved with value (muvaffaqiyatli yakunlandi) yoki resolved with error (xato bilan yakunlandi). Resolved holatiga o'tgandan keyin Future o'zgarmaydi.

JavaScript da Promise

Promise JavaScript da Dart Futureining analogi, ammo boyroq API bilan. Promise resolve va reject parametrlariga ega funksiyani — ekzekutorni qabul qiladi. Promise.all, Promise.race, Promise.allSettled statik metodlari bir nechta promislarni birlashtirishga imkon beradi. Zamonaviy ilovalar Promise ustida async/await sintaksisidan foydalanadi.

Future qanday ishlaydi

Future event loop — asosiy oqimni bloklamasdan asinxron operatsiyalarni qayta ishlovchi hodisa aylanishi asosida ishlaydi. Asinxron funksiya chaqirilganda (masalan, http.get), u darhol Future qaytaradi. Haqiqiy so'rov fonda bajariladi, event loop esa boshqa hodisalarni qayta ishlashni davom ettiradi. Operatsiya tugagandan so'ng Future resolved holatiga o'tadi va then chaqiriladi.

Event loop — Dart va JavaScript qurilgan asosiy mexanizm. Event loop ikkita navbatni saqlaydi: microtask queue (navbatdagi hodisadan oldin bajariladigan qisqa vazifalar) va event queue (IO hodisalari, taymerlar). Future.then callbackni microtask queue ga joylashtiradi, Future.microtask — navbatdagi kadrdan oldin ustuvor bajarish.

then() zanjirlari callback hellsiz asinxron operatsiyalar natijalarini ketma-ket qayta ishlashga imkon beradi. Har bir then() oldingi qadam natijasini oladi va yangi Future qaytaradi. Zanjir oxiridagi catchError() istalgan qadamda yuzaga kelgan xatoni qayta ishlaydi. Bu asinxron kodni chiziqli va o'qilishi oson qiladi.

Java da CompletableFuture

Java da CompletableFuture Future/Promise konsepsiyasini kengaytiradi. supplyAsync() metodi ForkJoinPool.commonPool() da asinxron vazifani ishga tushiradi. thenApply() natijani transformatsiya qiladi, thenCompose() — ichma-ich CompletableFuture ni ochadi. exceptionally() xatoni standart qiymat qaytarish bilan qayta ishlaydi. allOf() va anyOf() JavaScript dagi Promise.all va Promise.race kabi ishlaydi. CompletableFuture complete() va completeExceptionally() orqali qo'lda yakunlashni qo'llab-quvvatlaydi — bu Promise resolve/reject ning analogi.

Promise va asinxronlik kontrakti

Promise uch holatdan biri bilan kontrakt: pending (kutish), fulfilled (muvaffaqiyatli yakunlandi) yoki rejected (xato bilan yakunlandi). Fulfilled yoki rejected holatiga o'tgandan keyin Promise hech qachon o'zgarmaydi — bu barcha iste'molchilar uchun natijaning o'zgarmasligini kafolatlaydi. .then() metodi istalgan yakunlangan holatga o'tgandan keyin asinxron tarzda chaqiriladi.

Promise.all barcha uzatilgan promislarning tugashini kutadi va bir xil tartibda natijalar massivini qaytaradi. Agar bitta promise xato bilan yakunlansa — butun Promise.all rejected holatiga o'tadi. Promise.race birinchi tugagan promisning natijasini qaytaradi (muvaffaqiyat yoki xato). Promise.allSettled xatolardan qat'iy nazar barcha promislarni kutadi — har birining holatini qaytaradi.

Chaining — Promise ning callback dan asosiy ustunligi. Har bir .then() yangi Promise qaytaradi, ixtiyoriy uzunlikdagi zanjirlar qurishga imkon beradi. Zanjirning istalgan bo'g'inidagi xato eng yaqin .catch() gacha tarqaladi. finally() metodi natijadan qat'iy nazar zanjir tugagandan keyin kodni bajaradi — resurslarni tozalash uchun.

Future kod misollari (Dart)

Birinchi misol — async-funksiya orqali Future yaratish va then/catchError bilan qayta ishlash:

Future<String> fetchData() async {
    await Future.delayed(Duration(seconds: 1))
    return "Ma'lumotlar yuklandi"
}

fetchData()
    .then((result) => print(result))
    .catchError((error) => print("Xato: $error"))

Ikkinchi misol — bir nechta Future ni Future.wait orqali birlashtirish:

Future<List<String>> loadAll() async {
    final futures = [
        fetchFromApi("/users"),
        fetchFromApi("/posts"),
        fetchFromApi("/comments")
    ]
    final results = await Future.wait(futures)
    return results
}

Uchinchi misol — JavaScript da Promise ni qo'lda yaratish va then zanjiri:

const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("Tayyor")
    }, 1000)
})

promise
    .then(value => console.log(value))
    .catch(err => console.error(err))

Future vs boshqa asinxron namunalar

Future/Promise callback uslubidan farq qiladi, chunki u argument sifatida qayta chaqiruv funksiyasini qabul qilish o'rniga ob'ekt-kontrakt qaytaradi. Callback uslubi ichma-ichlikka (callback hell) olib keladi, Future esa tekis then() zanjirlarini qurishga imkon beradi. async/await sintaksisi Future bilan kodni yanada chiziqli, sinxron kodga o'xshash qiladi.

Future aynan bitta asinxron natijani ifodalaydi — bitta emissiya, shundan so'ng Future tugaydi. Observable (Rx, ReactiveX) yoki Flow (Kotlin Coroutines) dan farqli o'laroq, Future vaqt davomida ko'p qiymatlarni qo'llab-quvvatlamaydi. Agar hodisalar oqimi kerak bo'lsa — Dart da Stream, Rx da Observable yoki Kotlin da Flow dan foydalaning.

CompletableFuture Java da — kengaytirilgan API bilan Promise analogi: supplyAsync, thenApply, thenCompose, exceptionally. CompletableFuture allOf, anyOf orqali bir nechta asinxron operatsiyalarni birlashtirishga, shuningdek bajarish uchun o'z Executor ni belgilashga imkon beradi. Scala Future threadlar havzasini boshqarish uchun ExecutionContext dan foydalanadi va for-comprehension orqali kompozitsiyani qo'llab-quvvatlaydi.

Dart da Future namunasi JavaScript Promise dan farq qiladi, chunki Dart qattiq tipizatsiyaga ega: Future<String> qaytarilgan qiymat turini kafolatlaydi. Dart dagi async funksiyalari Future qaytarishi kerak va kompilyator barcha yo'llarning to'g'ri turni qaytarishini tekshiradi. Future.wait Promise.all ning ekvivalenti — Iterable<Future<T>> ni qabul qiladi va Future<List<T>> qaytaradi. Future.delayed va Future.error asinxron stsenariylarni test qilish uchun qulay fabrikalardir.

Future/Promise Python da concurrent.futures.Future va asyncio.Future orqali tatbiq etilgan. concurrent.futures.ThreadPoolExecutor.submit() Future qaytaradi, unda result() ni chaqirish mumkin — bloklovchi chaqiruv. asyncio.Future Asyncio da asinxron natija uchun await-mos konteyner. asyncio.gather() bir nechta korutinlarni parallel ishga tushiradi va natijalar ro'yxatini qaytaradi, xuddi JavaScript dagi Promise.all kabi. Python shuningdek asinxron operatsiyalar kompozitsiyasi uchun callback-based asyncio.ensure_future va add_done_callback zanjirlaridan foydalanadi, ammo zamonaviy kodda async/await sintaksisiga asyncio.Task bilan ustunlik beriladi.

Mobil dasturlashda Future Flutter ilovalarida faol qo'llaniladi. http yoki dio paketidan har bir tarmoq so'rovi Future qaytaradi. FutureBuilder — Future va holat snapshotini qabul qiluvchi vidjet: connectionDone, hasData, hasError. Ma'lumot olingandan so'ng snapshot.data Future natijasini o'z ichiga oladi. StreamBuilder — ko'p qiymatlar uchun analog. FutureBuilder setState orqali yuklash holatini qo'lda boshqarishni bartaraf qiladi.

Scala Future ExecutionContext dan yashirincha foydalanadi — asinxron vazifa bajariladigan threadlar havzasi. map, flatMap, filter orqali kompozitsiya Future monada bo'lgani uchun ishlaydi. for-comprehension bir nechta Future ni ichma-ichliksiz ketma-ket birlashtirishga imkon beradi: for { a <- futureA; b <- futureB } yield a + b. Future.sequence Promise.all kabi ishlaydi. Xato paytida zaxiraga qaytish recover va recoverWith orqali amalga oshiriladi.

Future/Promise C++ da <future> kutubxonasidan std::future va std::promise sinflari bilan ifodalanadi. std::async asinxron funksiyani ishga tushiradi va std::future qaytaradi. std::promise set_value() orqali qo'lda qiymat o'rnatishga yoki set_exception() orqali xato o'rnatishga imkon beradi. Dart va JavaScript dan farqli o'laroq, std::future.get() natija olinmaguncha threadni bloklaydi — bu C++ da ko'p threadli ilovalarni loyihalashda hisobga olinishi kerak bo'lgan muhim farqdir.

Future bilan ishlash namunalari

Future qaytaruvchi API larni loyihalashda yagona haqiqat manbai qoidasiga amal qiling: har bir asinxron so'rov bir marta yaratiladi va Future.memoize orqali keshga olinadi. Agar ikki komponent bir xil ma'lumotlarni so'rasa, ular bir xil Future ni oladi — bu so'rovlarning takrorlanishini oldini oladi. Timeout uchun Future.timeout (Dart) yoki timeout bilan Promise.race dan foydalaning, bu asinxron operatsiyaning belgilangan intervalda tugashini kafolatlaydi.

Retry namunasi Future da rekursiv zanjir orqali amalga oshiriladi: xato paytida catch da bir xil asinxron funksiya kechikish bilan chaqiriladi. Exponential backoff urinishlar orasidagi intervalni oshiradi: 1 sek — 2 sek — 4 sek — maks 30 sek. Dart da bu Future ga extension da inkapsulatsiya qilinadi: future.retry(maxRetries: 3, delay: Duration(seconds: 1)). Scala da Future.zip ikki mustaqil natijani tuple da birlashtiradi — ikki Future uchun Promise.all ga muqobil. Standart Future larda Cancellation qo'llab-quvvatlanmaydi, ammo JavaScript da CancellationToken yoki AbortController orqali amalga oshiriladi.