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 event loop — घटनाओं के चक्र पर आधारित काम करता है जो मुख्य थ्रेड को ब्लॉक किए बिना एसिंक्रोनस ऑपरेशनों को प्रोसेस करता है। जब कोई async फ़ंक्शन कॉल किया जाता है (जैसे http.get), यह तुरंत Future लौटाता है। वास्तविक अनुरोध पृष्ठभूमि में चलता है, जबकि event loop अन्य घटनाओं को प्रोसेस करता रहता है। ऑपरेशन पूरा होने के बाद, Future resolved अवस्था में आ जाता है और then कॉल किया जाता है।

Event loop वह प्रमुख तंत्र है जिस पर Dart और JavaScript निर्मित हैं। Event loop दो कतारें बनाए रखता है: microtask queue (छोटे कार्य, अगली घटना से पहले निष्पादित) और event queue (IO घटनाएँ, टाइमर)। Future.then microtask queue में callback रखता है, Future.microtask — अगले frame से पहले प्राथमिकता निष्पादन।

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 की प्रतीक्षा करता है — प्रत्येक की स्थिति लौटाता है।

चेनिंग callbacks पर 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 में Retry पैटर्न एक पुनरावर्ती चेन के माध्यम से कार्यान्वित किया जाता है: 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 के माध्यम से कार्यान्वित किया जाता है।