Future/Promise — ano ito, asynchronous na pag-compute at programming

Ano ang Future/Promise?

Future/Promise ay isang pares ng magkakaugnay na mga bagay na naghahati sa asynchronous na resulta sa dalawang papel. Ang Promise ay maaaring magsulat ng resulta (resolve) o error (reject). Ang Future ay maaari lamang basahin ito — sa pamamagitan ng callback (then, catchError) o sa pamamagitan ng await. Ang paghahati na ito ay ginagarantiyahan na ang consumer ay hindi maaaring baguhin ang resulta, gamitin lamang ito.

Future sa Dart

Ang wikang Dart ay gumagamit ng Future bilang pangunahing mekanismo ng asynchrony. Ang Future<T> ay isang kontrata para sa pagtanggap ng halaga ng uri T sa hinaharap. Ang Future ay maaaring nasa isa sa tatlong estado: unresolved (ang operasyon ay isinasagawa), resolved with value (matagumpay na natapos) o resolved with error (natapos na may error). Pagkatapos lumipat sa resolved na estado, ang Future ay hindi nagbabago.

Promise sa JavaScript

Promise sa JavaScript ay ang analog ng Future ng Dart, ngunit may mas mayamang API. Ang Promise ay tumatanggap ng executor — isang function na may mga parameter na resolve at reject. Ang mga static na pamamaraan na Promise.all, Promise.race, Promise.allSettled ay nagpapahintulot sa pagsasama-sama ng maraming promise. Ang mga modernong application ay gumagamit ng async/await syntax sa ibabaw ng Promise.

Paano gumagana ang Future

Future ay gumagana batay sa event loop — ang loop ng kaganapan na nagpoproseso ng mga asynchronous na operasyon nang hindi hinaharangan ang pangunahing thread. Kapag ang isang asynchronous na function ay tinawag (hal. http.get), ito ay agad na nagbabalik ng Future. Ang aktwal na kahilingan ay isinasagawa sa background, habang ang event loop ay patuloy na nagpoproseso ng iba pang mga kaganapan. Pagkatapos makumpleto ang operasyon, ang Future ay lumipat sa resolved na estado at ang then ay tinatawag.

Event loop ay ang pangunahing mekanismo kung saan itinayo ang Dart at JavaScript. Ang event loop ay nagpapanatili ng dalawang queue: microtask queue (maikling gawain na isinasagawa bago ang susunod na kaganapan) at event queue (mga kaganapan sa IO, timer). Ang Future.then ay naglalagay ng callback sa microtask queue, ang Future.microtask — priority na pagpapatupad bago ang susunod na frame.

Ang mga chain ng then() ay nagpapahintulot sa sunud-sunod na pagproseso ng mga resulta ng asynchronous na operasyon nang walang callback hell. Ang bawat then() ay tumatanggap ng resulta ng nakaraang hakbang at nagbabalik ng bagong Future. Ang catchError() sa dulo ng chain ay nagpoproseso ng anumang error na naganap sa anumang hakbang. Ginagawa nitong linear at nababasa ang asynchronous na code.

CompletableFuture sa Java

Sa Java, ang CompletableFuture ay nagpapalawak ng konsepto ng Future/Promise. Ang pamamaraang supplyAsync() ay naglulunsad ng asynchronous na gawain sa ForkJoinPool.commonPool(). Ang thenApply() ay nag-transform ng resulta, ang thenCompose() — nagbubukas ng nested na CompletableFuture. Ang exceptionally() ay nagpoproseso ng error na may pagbabalik ng default na halaga. Ang allOf() at anyOf() ay gumagana tulad ng Promise.all at Promise.race sa JavaScript. Sinusuportahan ng CompletableFuture ang manu-manong pagkumpleto sa pamamagitan ng complete() at completeExceptionally() — ito ang analog ng Promise resolve/reject.

Promise at ang asynchronous na kontrata

Promise ay isang kontrata na may isa sa tatlong estado: pending (naghihintay), fulfilled (matagumpay na natapos) o rejected (natapos na may error). Pagkatapos lumipat sa fulfilled o rejected na estado, ang Promise ay hindi na nagbabago — ginagarantiyahan nito ang immutability ng resulta para sa lahat ng consumer. Ang pamamaraang .then() ay tinatawag nang asynchronous pagkatapos lumipat sa anumang natapos na estado.

Promise.all ay naghihintay para sa pagkumpleto ng lahat ng ibinigay na promise at nagbabalik ng array ng mga resulta sa parehong pagkakasunud-sunod. Kung ang isang promise ay natapos na may error — ang buong Promise.all ay napupunta sa rejected. Ang Promise.race ay nagbabalik ng resulta ng unang promise na natapos (tagumpay o error). Ang Promise.allSettled ay naghihintay para sa lahat ng promise anuman ang mga error — nagbabalik ng status ng bawat isa.

Chaining — ang pangunahing bentahe ng Promise kumpara sa callback. Ang bawat .then() ay nagbabalik ng bagong Promise, na nagpapahintulot sa pagbuo ng mga chain ng arbitraryong haba. Ang isang error sa anumang link ng chain ay ipinapasa hanggang sa pinakamalapit na .catch(). Ang pamamaraang finally() ay nagpapatupad ng code pagkatapos makumpleto ang chain anuman ang resulta — para sa paglilinis ng mga mapagkukunan.

Mga halimbawa ng code ng Future (Dart)

Unang halimbawa — paggawa ng Future sa pamamagitan ng async-function at pagproseso sa pamamagitan ng then/catchError:

Future<String> fetchData() async {
    await Future.delayed(Duration(seconds: 1))
    return "Na-load ang data"
}

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

Ikalawang halimbawa — pagsasama-sama ng maraming Future sa pamamagitan ng Future.wait:

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

Ikatlong halimbawa — Promise sa JavaScript na may manu-manong paggawa at chain ng then:

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

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

Future vs iba pang asynchronous na pattern

Future/Promise ay naiiba sa estilo ng callback dahil nagbabalik ito ng object-kontrata sa halip na tumanggap ng callback function bilang argumento. Ang estilo ng callback ay humahantong sa nesting (callback hell), habang ang Future ay nagpapahintulot sa pagbuo ng mga flat chain ng then(). Ang async/await syntax ay ginagawang mas linear ang code na may Future, katulad ng synchronous code.

Future ay kumakatawan sa eksaktong isang asynchronous na resulta — isang emisyon, pagkatapos nito ang Future ay nagtatapos. Hindi tulad ng Observable (Rx, ReactiveX) o Flow (Kotlin Coroutines), ang Future ay hindi sumusuporta sa maraming halaga sa paglipas ng panahon. Kung kailangan mo ng stream ng mga kaganapan — gamitin ang Stream sa Dart, Observable sa Rx o Flow sa Kotlin.

CompletableFuture sa Java — ang analog ng Promise na may pinalawak na API: supplyAsync, thenApply, thenCompose, exceptionally. Ang CompletableFuture ay nagpapahintulot sa pagsasama-sama ng maraming asynchronous na operasyon sa pamamagitan ng allOf, anyOf, pati na rin ang pagtatakda ng sariling Executor para sa pagpapatupad. Ang Scala Future ay gumagamit ng ExecutionContext para sa pamamahala ng thread pool at sumusuporta sa komposisyon sa pamamagitan ng for-comprehension.

Sa Dart, ang pattern ng Future ay naiiba mula sa JavaScript Promise dahil ang Dart ay may mahigpit na pag-type: Future<String> ay ginagarantiyahan ang uri ng ibinalik na halaga. Ang mga async function sa Dart ay dapat magbalik ng Future, at sinusuri ng compiler kung ang lahat ng mga landas ay nagbabalik ng tamang uri. Ang Future.wait ay katumbas ng Promise.all — tumatanggap ng Iterable<Future<T>> at nagbabalik ng Future<List<T>>. Ang Future.delayed at Future.error ay maginhawang mga pabrika para sa pagsubok ng mga asynchronous na senaryo.

Ang Future/Promise ay ipinatupad sa Python sa pamamagitan ng concurrent.futures.Future at asyncio.Future. Ang concurrent.futures.ThreadPoolExecutor.submit() ay nagbabalik ng Future na maaaring tawagan ng result() — isang blocking na tawag. Ang asyncio.Future ay isang container na katugma sa await para sa asynchronous na resulta sa Asyncio. Ang asyncio.gather() ay nagpapatakbo ng maraming coroutine nang magkatulad at nagbabalik ng listahan ng mga resulta, katulad ng Promise.all sa JavaScript. Gumagamit din ang Python ng callback-based na asyncio.ensure_future at mga chain ng add_done_callback para sa komposisyon ng mga asynchronous na operasyon, ngunit sa modernong code, ang async/await syntax na may asyncio.Task ay mas pinipili.

Sa pag-develop ng mobile, ang Future ay aktibong ginagamit sa mga Flutter application. Ang bawat kahilingan sa network mula sa http o dio package ay nagbabalik ng Future. Ang FutureBuilder — isang widget na tumatanggap ng Future at snapshot ng estado: connectionDone, hasData, hasError. Sa pagtanggap ng data, ang snapshot.data ay naglalaman ng resulta ng Future. Ang StreamBuilder — analog para sa maraming halaga. Inaalis ng FutureBuilder ang manu-manong pamamahala ng estado ng pag-load sa pamamagitan ng setState.

Ang Scala Future ay tahasang gumagamit ng ExecutionContext — ang thread pool kung saan isinasagawa ang asynchronous na gawain. Ang komposisyon sa pamamagitan ng map, flatMap, filter ay gumagana dahil ang Future ay isang monad. Ang for-comprehension ay nagpapahintulot sa sunud-sunod na pagsasama-sama ng maraming Future nang walang nesting: for { a <- futureA; b <- futureB } yield a + b. Ang Future.sequence ay gumagana tulad ng Promise.all. Ang fallback sa error ay ipinatupad sa pamamagitan ng recover at recoverWith.

Future/Promise sa C++ ay kinakatawan ng mga klase na std::future at std::promise mula sa library na <future>. Ang std::async ay naglulunsad ng asynchronous na function at nagbabalik ng std::future. Ang std::promise ay nagpapahintulot sa manu-manong pagtatakda ng halaga sa pamamagitan ng set_value() o error sa pamamagitan ng set_exception(). Hindi tulad ng Dart at JavaScript, ang std::future.get() ay humaharang sa thread hanggang sa matanggap ang resulta — ito ay isang mahalagang pagkakaiba na dapat isaalang-alang kapag nagdidisenyo ng multi-threaded na application sa C++.

Mga pattern ng pagtatrabaho sa Future

Kapag nagdidisenyo ng mga API na nagbabalik ng Future, sundin ang panuntunan ng nag-iisang pinagmumulan ng katotohanan: bawat asynchronous na kahilingan ay ginagawa nang isang beses at naka-cache sa pamamagitan ng Future.memoize. Kung ang dalawang component ay humihingi ng parehong data, nakakakuha sila ng parehong Future — pinipigilan nito ang pagdoble ng mga kahilingan. Para sa timeout, gamitin ang Future.timeout (Dart) o Promise.race na may timeout upang garantiyahan na ang asynchronous na operasyon ay makukumpleto sa loob ng tinukoy na agwat.

Pattern ng Retry sa Future ay ipinatupad sa pamamagitan ng recursive chain: sa error sa catch, ang parehong asynchronous na function ay tinatawag na may pagkaantala. Ang Exponential backoff ay nagpapataas ng agwat sa pagitan ng mga pagtatangka: 1 seg — 2 seg — 4 seg — hanggang max 30 seg. Sa Dart, ito ay naka-encapsulate sa isang extension sa Future: future.retry(maxRetries: 3, delay: Duration(seconds: 1)). Sa Scala, ang Future.zip ay nagsasama ng dalawang independiyenteng resulta sa isang tuple — alternatibo sa Promise.all para sa dalawang Future. Ang pagkansela ay hindi sinusuportahan sa mga standard na Future, ngunit ipinatupad sa pamamagitan ng CancellationToken o AbortController sa JavaScript.