C++ में एसिंक्रोनस प्रोग्रामिंग: पूर्ण गाइड

C++ में एसिंक्रोनस प्रोग्रामिंग: पूर्ण गाइड

आधुनिक एप्लिकेशन उच्च प्रदर्शन और प्रतिक्रियाशीलता की मांग करते हैं। C++ में एसिंक्रोनस प्रोग्रामिंग आपको मुख्य थ्रेड को ब्लॉक किए बिना लंबी अवधि के ऑपरेशन (इनपुट-आउटपुट, नेटवर्क अनुरोध, जटिल गणनाएं) करने की अनुमति देती है। इस गाइड में, हम एसिंक्रोनस कार्य के लिए C++ के प्रमुख मैकेनिज्म को समझेंगे: क्लासिक std::thread और std::async से लेकर आधुनिक C++20 कोरूटीन तक। आप सीखेंगे कि कुशल और सुरक्षित एसिंक्रोनस कोड कैसे लिखें।

1. मूल बातें: std::thread और std::async

बुनियादी टूल से शुरू करते हैं। std::thread एक नया निष्पादन थ्रेड बनाता है, लेकिन मैन्युअल प्रबंधन और सिंक्रोनाइज़ेशन की आवश्यकता होती है। अधिक सुविधाजनक विकल्प std::async है, जो किसी फ़ंक्शन को एसिंक्रोनस रूप से चलाता है और परिणाम प्राप्त करने के लिए std::future लौटाता है।

#include <iostream>#include <future>#include <chrono>

int long_running_task(int input) {    std::this_thread::sleep_for(std::chrono::seconds(2));    return input * 10;}

int main() {    std::cout << "एसिंक्रोनस कार्य शुरू कर रहे हैं...";    std::future<int> result = std::async(std::launch::async, long_running_task, 5);        // कार्य निष्पादित होने के दौरान कुछ उपयोगी करें    std::cout << "मुख्य थ्रेड काम करता रहता है...";        // परिणाम प्राप्त करें (यदि कार्य अभी पूरा नहीं हुआ है तो ब्लॉक होता है)    int value = result.get();    std::cout << "परिणाम: " << value << std::endl;    return 0;}

मुख्य बिंदु:

• std::launch::async — एक अलग थ्रेड में लॉन्च की गारंटी देता है।
• std::launch::deferred — get() कॉल होने तक निष्पादन को स्थगित करता है।
• get() मेथड परिणाम प्राप्त होने तक थ्रेड को ब्लॉक करता है।

2. उन्नत कार्य: std::promise और std::future

जब एक थ्रेड से दूसरे थ्रेड में परिणाम स्थानांतरित करने की आवश्यकता होती है, तो std::promise और std::future की जोड़ी का उपयोग करें। promise मान सेट करता है, और future इसे प्राप्त करता है। यह थ्रेड पूलिंग या कार्य श्रृंखलाओं में विशेष रूप से उपयोगी है।

#include <iostream>#include <future>#include <thread>

void worker(std::promise<int> prom) {    try {        int result = 42; // जटिल गणनाएं        prom.set_value(result);    } catch (...) {        prom.set_exception(std::current_exception());    }}

int main() {    std::promise<int> prom;    std::future<int> fut = prom.get_future();        std::thread t(worker, std::move(prom));        // परिणाम प्राप्त करें    int value = fut.get();    std::cout << "मान प्राप्त हुआ: " << value << std::endl;        t.join();    return 0;}

महत्वपूर्ण विशेषताएं:

• promise को कॉपी नहीं किया जा सकता, केवल मूव किया जा सकता है।
• अपवाद set_exception के माध्यम से पास किए जाते हैं।
• future का उपयोग केवल एक बार किया जा सकता है (एकल प्राप्ति)।

3. C++20 कोरूटीन: आधुनिक दृष्टिकोण

कोरूटीन (coroutines) C++20 में जोड़ा गया एक शक्तिशाली टूल है। वे थ्रेड को ब्लॉक किए बिना फ़ंक्शन के निष्पादन को रोकने और फिर से शुरू करने की अनुमति देते हैं। यह एसिंक्रोनस इनपुट-आउटपुट ऑपरेशन और जनरेटर के लिए आदर्श है।

#include <iostream>#include <coroutine>#include <future>

struct SimpleTask {    struct promise_type {        SimpleTask get_return_object() { return {}; }        std::suspend_never initial_suspend() { return {}; }        std::suspend_never final_suspend() noexcept { return {}; }        void return_void() {}        void unhandled_exception() { std::exit(1); }    };};

SimpleTask async_operation() {    std::cout << "कोरूटीन की शुरुआत";```