Future/Promise — یہ کیا ہے، متزامن حساب اور پروگرامنگ

Future/Promise کیا ہے؟

Future/Promise آپس میں منسلک اوبجیکٹس کا ایک جوڑا ہے جو ایک متزامن نتیجے کو دو کرداروں میں تقسیم کرتا ہے۔ Promise نتیجہ (resolve) یا غلطی (reject) لکھ سکتا ہے۔ Future اسے صرف پڑھ سکتا ہے — callback (then، catchError) یا await کے ذریعے۔ یہ علاحدگی اس بات کی ضمانت دیتی ہے کہ صارف نتیجے کو بدل نہیں سکتا، صرف استعمال کر سکتا ہے۔

Dart میں Future

Dart زبان Future کو اپنے اہم متزامن میکانزم کے طور پر استعمال کرتی ہے۔ Future<T> مستقبل میں T قسم کی قیمت حاصل کرنے کا ایک معاہدہ ہے۔ Future تین حالات میں سے ایک میں ہو سکتا ہے: unresolved (آپریشن جاری)، resolved with value (کامیابی سے مکمل) یا resolved with error (غلطی کے ساتھ مکمل)۔ ایک دفعہ resolved حالت میں جانے کے بعد، Future کبھی نہیں بدلتا۔

JavaScript میں Promise

JavaScript میں Promise Dart کے Future کے ممانہ ہے، لیکن ایک امیر API کے ساتھ۔ Promise ایک executor لیتا ہے — resolve اور reject پیرامیٹر کے ساتھ ایک فنکشن۔ ستاٹک میتھڈ Promise.all، Promise.race، Promise.allSettled ایک سے زیادہ promoses کو ملانے کی اجازت دیتے ہیں۔ جدید ایپلیکیشنز Promise کے اوپر async/await سین ٹیکس استعمال کرتے ہیں۔

Future کیسے کام کرتا ہے

Future ایونٹ لوپ — ایک واقعات کا چکر جو مرکزی تھریڈ کو روکے بغیر متزامن آپریشنوں کو پروسیس کرتا ہے — کی بنیاد پر کام کرتا ہے۔ جب ایک async فنکشن کو بلایا جاتا ہے (مثالاں، http.get)، یہ فورا ایک Future واپس کرتا ہے۔ حقیقی درخواست پس منزر میں چلتی ہے، جبکہ ایونٹ لوپ دیگر واقعات کو پروسیس کرتا رہتا ہے۔ آپریشن مکمل ہونے کے بعد، Future resolved حالت میں چلا جاتا ہے اور then کو بلایا جاتا ہے۔

ایونٹ لوپ وہ کلیڈی میکانزم ہے جس پر Dart اور JavaScript تعمیر کیے گئے ہیں۔ ایونٹ لوپ دو قطاریں برقرار رکھتا ہے: مائیکرو ٹاسک قطار (مختصر کام، اگلے واقعے سے پہلے نفذ کیے جاتے ہیں) اور ایونٹ قطار (IO واقعات، ٹائمر)۔ Future.then مائیکرو ٹاسک قطار میں ایک callback رکھتا ہے، Future.microtask — اگلے فریم سے پہلے ترجیحی نفاذ۔

then() کی زنجیریں callback hell کے بغیر متزامن آپریشن نتائج کی مسلسل پروسیسنگ کی اجازت دیتی ہیں۔ ہر then() پځھلے مرحلے کا نتیجہ لیتا ہے اور ایک نیا Future واپس کرتا ہے۔ زنجیر کے آخر میں catchError() کسی بھی مرحلے پر واقع ہونے والی کسی بھی غلطی کو ہینڈل کرتا ہے۔ یہ متزامن کوڈ کو لینیئر اور پڑھنے قابل بناتا ہے۔

Java میں CompletableFuture

Java میں، CompletableFuture Future/Promise کے تصور کو وسیع کرتا ہے۔ supplyAsync() طریقہ ForkJoinPool.commonPool() میں ایک متزامن کام شروع کرتا ہے۔ thenApply() نتیجے کو تبدیل کرتا ہے، thenCompose() ایک دوسرے میں گھرے CompletableFuture کو کھولتا ہے۔ exceptionally() ایک ڈیفالٹ قیمت واپس کرکے غلطی کو ہینڈل کرتا ہے۔ allOf() اور anyOf() JavaScript میں Promise.all اور Promise.race کی طرح کام کرتے ہیں۔ CompletableFuture complete() اور completeExceptionally() کے ذریعے دستی تکمیل کی حمایت کرتا ہے — یہ Promise resolve/reject کے مشابہ ہے۔

Promise اور متزامن معاہدہ

Promise تین حالات میں سے ایک کے ساتھ ایک معاہدہ ہے: pending (منتظر)، fulfilled (پورا ہوا) یا rejected (مسترد)۔ ایک دفعہ fulfilled یا rejected میں جانے کے بعد، Promise کبھی نہیں بدلتا — یہ تمام صارفین کے لیے نتیجے کی ناقابل تغییری کی ضمانت دیتا ہے۔ .then() طریقہ کسی بھی مکمل حالت میں جانے کے بعد متزامن طور پر بلایا جاتا ہے۔

Promise.all تمام گزرے گئے promoses کے مکمل ہونے کا انتظار کرتا ہے اور ایک ہی ترتیب میں نتائج کی ایک ارے واپس کرتا ہے۔ اگر ایک promise غلطی سے ناکام ہوتا ہے — پورا Promise.all rejected میں چلا جاتا ہے۔ Promise.race پہلے مکمل promise کا نتیجہ (کامیابی یا غلطی) واپس کرتا ہے۔ Promise.allSettled غلطیوں سے آزاد تمام promoses کا انتظار کرتا ہے — ہر ایک کی حالت واپس کرتا ہے۔

زنجیر سازی callback کے مقابلے میں Promise کا اہم فائدہ ہے۔ ہر .then() ایک نیا Promise واپس کرتا ہے، جو صف کی من صافی لمبائی کی زنجیروں کی اجازت دیتا ہے۔ زنجیر کے کسی بھی کڑی میں غلطی قریبی .catch() تک پھیلتی ہے۔ finally() طریقہ نتیجے سے آزاد زنجیر مکمل ہونے کے بعد کوڈ پر چلاتا ہے — وسائل کی صفائی کے لیے۔

Future کوڈ مثالیں (Dart)

پہلی مثال — async فنکشن کے ذریعے Future بنانا اور then/catchError سے ہینڈل کرنا:

Future<String> fetchData() async {
    await Future.delayed(Duration(seconds: 1))
    return "ڈیٹا لوڈ ہوگیا"
}

fetchData()
    .then((result) => print(result))
    .catchError((error) => print("غلطی: $error"))

دوسری مثال — Future.wait کے ساتھ ایک سے زیادہ Futures کو ملانا:

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

تیسری مثال — دستی تخلیق اور then زنجیر کے ساتھ JavaScript میں Promise:

const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("هو گیا")
    }, 1000)
})

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

Future بقابل دیگر متزامن پیٹرنز

Future/Promise callback فنکشن کو ارگیومنٹ کے طور پر قبول کرنے کے بجائے ایک معاہدہ آبجیکٹ واپس کرنے میں callback انداز سے مختلف ہے۔ Callback انداز ایک دوسرے میں گھرنے (callback hell) کی طرف لے جاتا ہے، جبکہ Future چپٹی then() زنجیریں بنانے کی اجازت دیتا ہے۔ async/await سین ٹیکس Future کوڈ کو مزید لینیئر بناتا ہے، سنکرونس کوڈ کے مشابہ۔

Future بلکل ایک متزامن نتیجے کی نمائندگی کرتا ہے — ایک اخراج، جس کے بعد Future مکمل ہوجاتا ہے۔ Observable (Rx، ReactiveX) یا Flow (Kotlin Coroutines) کے برعکس، Future وقت کے ساتھ ایک سے زیادہ قیمتوں کی حمایت نہیں کرتا۔ اگر آپ کو واقعات کے سٹریم کی ضرورت ہے — Dart میں Stream، Rx میں Observable یا Kotlin میں Flow استعمال کریں۔

Java میں CompletableFuture وسیع API کے ساتھ Promise کا ایک مترادف ہے: supplyAsync، thenApply، thenCompose، exceptionally۔ CompletableFuture allOf، anyOf کے ذریعے ایک سے زیادہ متزامن آپریشنوں کو ملانے کی اجازت دیتا ہے اور استعمال کے لیے ایک کسٹم Executor متعین کرنے کی بھی اجازت دیتا ہے۔ Scala Future تھریڈ پول کے انتظام کے لیے ExecutionContext استعمال کرتا ہے اور for-comprehension کے ذریعے ترکیب کی حمایت کرتا ہے۔

Dart میں، Future پیٹرن JavaScript Promise سے مختلف ہے کیونکہ Dart میں سخت ٹائپنگ ہے: Future<String> واپسی قیمت کی قسم کی ضمانت دیتا ہے۔ Dart میں async فنکشنز کو Future واپس کرنا ہوتا ہے، اور کمپائلر چیک کرتا ہے کہ تمام راستے ایک صحیح قسم واپس کرتے ہیں۔ Future.wait Promise.all کے مساوی ہے — یہ Iterable<Future<T>> لیتا ہے اور Future<List<T>> واپس کرتا ہے۔ Future.delayed اور Future.error متزامن مناظر کے پریکشن کے لیے آسان فیکٹریاں ہیں۔

Future/Promise Python میں concurrent.futures.Future اور asyncio.Future کے ذریعے نفذ کیا گیا ہے۔ concurrent.futures.ThreadPoolExecutor.submit() ایک Future واپس کرتا ہے، جس پر result() بلایا جا سکتا ہے — ایک روکنے والی کال۔ asyncio.Future Asyncio میں متزامن نتیجے کے لیے ایک await مطابق کنٹینر ہے۔ asyncio.gather() متوازی میں ایک سے زیادہ coroutines چلاتا ہے اور نتائج کی ایک فہرست واپس کرتا ہے، JavaScript میں Promise.all کے مشابہ۔ Python متزامن آپریشنوں کی ترکیب کے لیے callback پر مبنی asyncio.ensure_future اور add_done_callback زنجیریں بھی استعمال کرتا ہے، لیکن جدید کوڈ میں asyncio.Task کے ساتھ async/await سین ٹیکس ترجیح دیا جاتا ہے۔

موبائل ڈیولپمنٹ میں، Future Flutter ایپلیکیشنز میں فعال طور پر استعمال ہوتا ہے۔ http یا dio پیکیج سے ہر نیٹ ورک درخواست ایک Future واپس کرتی ہے۔ FutureBuilder ایک وائجٹ ہے جو Future اور snapshot حالت (connectionDone، hasData، hasError) لیتا ہے۔ جب ڈیٹا موصول ہوتا ہے، snapshot.data میں Future کا نتیجہ ہوتا ہے۔ StreamBuilder ایک سے زیادہ قیمتوں کے لیے مترادف ہے۔ FutureBuilder setState کے ذریعے دستی لوڈنگ حالت انتظام کو ختم کرتا ہے۔

Scala Future ضمنی طور پر ExecutionContext استعمال کرتا ہے — وہ تھریڈ پول جس پر متزامن کام پر چلتا ہے۔ map، flatMap، filter کے ذریعے ترکیب اس لیے کام کرتی ہے کیونکہ Future ایک monad ہے۔ for-comprehension بغیر کسی ایک میں گھرے ایک سے زیادہ Futures کو مسلسل طور پر ملانے کی اجازت دیتا ہے: for { a <- futureA; b <- futureB } yield a + b۔ Future.sequence Promise.all کی طرح کام کرتا ہے۔ غلطی کی واپسی recover اور recoverWith کے ذریعے نفذ کی جاتی ہے۔

C++ میں Future/Promise <future> لائبری سے std::future اور std::promise کلاسز سے ظاہر ہے۔ std::async ایک متزامن فنکشن شروع کرتا ہے اور std::future واپس کرتا ہے۔ std::promise set_value() کے ذریعے دستی طور پر قیمت یا set_exception() کے ذریعے غلطی مقرر کرنے کی اجازت دیتا ہے۔ Dart اور JavaScript کے برعکس، std::future.get() نتیجہ موصول ہونے تک تھریڈ کو روکتا ہے — یہ ایک اہم فرق ہے جسے ملٹی تھریڈیڈ C++ ایپلیکیشنز ڈیزائن کرتے وقت دھیان میں رکھنا چاہیے۔

Future کے پیٹرنز

Future واپس کرنے والے APIs کو ڈیزائن کرتے وقت، واحد سچائی کے مخذ کے اصول پر عمل کریں: ہر متزامن درخواست ایک دفعہ بنائی جاتی ہے اور Future.memoize کے ذریعے کیش کی جاتی ہے۔ اگر دو اجزاء ایک ہی ڈیٹا کی درخواست کرتے ہیں، انہیں ایک ہی Future ملتا ہے — یہ مکرر درخواستوں کو روکتا ہے۔ ٹائم آؤٹ کے لیے، Future.timeout (Dart) یا ٹائم آؤٹ کے ساتھ Promise.race استعمال کریں تاکہ یقینی ہو کہ متزامن آپریشن ایک مقرر کردہ وقتی فاصلے میں مکمل ہو۔

Future میں دوبارہ کوشش کا پیٹرن ایک تکراری زنجیر کے ذریعے نفذ کیا جاتا ہے: catch میں غلطی پر، وہی متزامن فنکشن ایک تاخیر کے ساتھ بلایا جاتا ہے۔ Exponential backoff کوششوں کے درمیان فاصلہ بڑھاتا ہے: 1 سیکنڈ — 2 سیکنڈ — 4 سیکنڈ — زیادہ سے زیادہ 30 سیکنڈ تک۔ Dart میں یہ Future پر ایک extension میں لپیٹا گیا ہے: future.retry(maxRetries: 3, delay: Duration(seconds: 1))۔ Scala میں، Future.zip دو آزاد نتائج کو ایک tuple میں ملاتا ہے — دو Futures کے لیے Promise.all کا ایک متبادل۔ معیاری Futures میں منسوخی کی حمایت نہیں ہے، لیکن JavaScript میں CancellationToken یا AbortController کے ذریعے نفذ کی جاتی ہے۔