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

C++ में एसिंक्रोनस प्रोग्रामिंग: std::async से कोरूटीन तक

C++ में एसिंक्रोनस प्रोग्रामिंग उच्च-प्रदर्शन और उत्तरदायी एप्लिकेशन बनाने के लिए एक शक्तिशाली उपकरण है। आधुनिक दुनिया में, जहां मल्टी-कोर प्रोसेसर मानक बन गए हैं, समानांतर कार्यों को कुशलतापूर्वक प्रबंधित करने की क्षमता प्रत्येक C++ डेवलपर के लिए एक अनिवार्य कौशल है। इस लेख में, हम मानक लाइब्रेरी के बुनियादी तंत्र से लेकर C++20 के आधुनिक कोरूटीन तक, मुख्य अवधारणाओं पर चर्चा करेंगे।

एसिंक्रोनस प्रोग्रामिंग की आवश्यकता क्यों है?

एसिंक्रोनस प्रोग्रामिंग का मुख्य उद्देश्य प्रोग्राम के मुख्य निष्पादन थ्रेड को ब्लॉक नहीं करना है। कल्पना करें कि आपके एप्लिकेशन को नेटवर्क से एक फ़ाइल डाउनलोड करनी है, उसे प्रोसेस करना है और उपयोगकर्ता को दिखाना है। यदि आप इन ऑपरेशनों को सिंक्रोनस रूप से करते हैं, तो डाउनलोड के दौरान इंटरफ़ेस "फ्रीज़" हो जाएगा। एसिंक्रोनस दृष्टिकोण लंबे ऑपरेशन को "बैकग्राउंड" में चलाने की अनुमति देता है, जबकि मुख्य थ्रेड उपयोगकर्ता इनपुट को प्रोसेस करता रहता है।

C++ में एसिंक्रोनसिटी के मुख्य दृष्टिकोण

C++ में एसिंक्रोनस निष्पादन को लागू करने के कई तरीके हैं:

• थ्रेड्स का मैन्युअल प्रबंधन (std::thread) — निम्न-स्तरीय लेकिन लचीला दृष्टिकोण।
• std::async और std::future — एसिंक्रोनस कार्यों को शुरू करने के लिए उच्च-स्तरीय तंत्र।
• std::packaged_task और std::promise — अधिक सूक्ष्म नियंत्रण के लिए।
• कोरूटीन (C++20) — एसिंक्रोनस कोड लिखने का आधुनिक और सुरुचिपूर्ण तरीका।

std::async और std::future का उपयोग

एसिंक्रोनस कार्य शुरू करने का यह सबसे सरल तरीका है। फ़ंक्शन std::async एक std::future ऑब्जेक्ट लौटाता है, जिसमें निष्पादन का परिणाम होगा।

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

int heavy_computation(int x) {    std::this_thread::sleep_for(std::chrono::seconds(2));    return x * x;}

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

फ़्लैग std::launch::async गारंटी देता है कि कार्य एक अलग थ्रेड में निष्पादित होगा। यदि इसे निर्दिष्ट नहीं किया गया है, तो कार्यान्वयन .get() कॉल तक निष्पादन को स्थगित कर सकता है।

std::promise और std::packaged_task के साथ कार्य करना

ये तंत्र अधिक नियंत्रण प्रदान करते हैं। std::promise एक मान का "वादा" करने की अनुमति देता है जिसे बाद में सेट किया जाएगा, जबकि std::packaged_task एक कॉल करने योग्य ऑब्जेक्ट को एक कार्य में लपेटता है।

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

void set_value(std::promise<int>&& prom) {    std::this_thread::sleep_for(std::chrono::seconds(1));    prom.set_value(100);}

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

महत्वपूर्ण: std::promise और std::future केवल move-only ऑब्जेक्ट हैं। इन्हें कॉपी नहीं किया जा सकता, केवल स्थानांतरित किया जा सकता है।

C++20 में कोरूटीन: एसिंक्रोनसिटी का नया स्तर

कोरूटीन (coroutines) ऐसे फ़ंक्शन हैं जो अपने निष्पादन को रोक सकते हैं और बाद में इसे फिर से शुरू कर सकते हैं। वे एसिंक्रोनस कोड को इस तरह लिखने की अनुमति देते हैं जैसे कि वह सिंक्रोनस हो।

बेसिक