"Boost.Asio C ++ नेटवर्क प्रोग्रामिंग।" अध्याय 1: Boost.Asio के साथ शुरुआत करना

हाय हबरलुडी!
यह मेरी पहली पोस्ट है, इसलिए कड़ाई से न्याय न करें। मैं जॉन टोरजो की पुस्तक Boost.Asio C ++ नेटवर्क प्रोग्रामिंग का मुफ्त अनुवाद शुरू करना चाहता हूं, यहां इसकी एक कड़ी है।

सामग्री:

• अध्याय 1: Boost.Asio के साथ शुरुआत करना
• अध्याय 2: बूस्ट.आसियो मूल बातें
  
  • भाग 1: Boost.Asio की मूल बातें
  • भाग 2: अतुल्यकालिक प्रोग्रामिंग
• अध्याय 3: इको सर्वर / क्लाइंट
• अध्याय 4: क्लाइंट और सर्वर
• अध्याय 5: सिंक्रोनस बनाम एसिंक्रोनस
• अध्याय 6: Boost.Asio - अन्य विशेषताएं
• अध्याय 7: Boost.Asio - अतिरिक्त विषय

सबसे पहले, आइए देखें कि Boost.Asio क्या है, इसे कैसे इकट्ठा किया जाए, साथ ही कुछ उदाहरण भी। आप सीखेंगे कि Boost.Asio एक नेटवर्क लाइब्रेरी से अधिक है। आप सबसे महत्वपूर्ण वर्ग के बारे में भी जानेंगे, जो Boost.Asio - io_service के केंद्र में स्थित है।

Boost.Asio क्या है?

संक्षेप में, Boost.Asio, अधिकांश भाग के लिए, प्रोग्रामिंग नेटवर्क के लिए एक क्रॉस-प्लेटफ़ॉर्म C ++ लाइब्रेरी और कुछ अन्य निम्न-स्तरीय I / O प्रोग्राम हैं।
नेटवर्क समस्याओं को हल करने के लिए कई कार्यान्वयन हैं, लेकिन Boost.Asio ने उन सभी को पार कर लिया है; 2005 में बूस्ट द्वारा इसे अपनाया गया था और तब से इसे बड़ी संख्या में बूस्ट उपयोगकर्ताओं द्वारा परीक्षण किया गया है, और कई परियोजनाओं में उपयोग किया जाता है, जैसे:

• रेमोबो , आपको अपना आईपीएन बनाने की अनुमति देता है
• libtorrent , एक पुस्तकालय है जो बिटटोरेंट क्लाइंट को लागू करता है
• पोकर, लैन और इंटरनेट समर्थन के साथ एक पोकर गेम है

Boost.Asio इनपुट और आउटपुट की अवधारणाओं को सफलतापूर्वक अमूर्त करता है, जो न केवल नेटवर्किंग के लिए काम करता है, बल्कि सीरियल COM पोर्ट्स, फाइल्स, आदि के लिए भी काम करता है। इसके अलावा, आप इनपुट या आउटपुट प्रोग्रामिंग को सिंक्रोनस या एसिंक्रोनस बना सकते हैं:

 read(stream, buffer [, extra options]) async_read(stream, buffer [, extra options], handler) write(stream, buffer [, extra options]) async_write(stream, buffer [, extra options], handler) 

जैसा कि आप पिछले कोड स्निपेट में देख सकते हैं, फ़ंक्शन स्ट्रीम का एक उदाहरण स्वीकार करते हैं, जो कुछ भी हो सकता है (न केवल एक सॉकेट, हम इसे पढ़ सकते हैं और लिख सकते हैं)।
पुस्तकालय पोर्टेबल है, अधिकांश ऑपरेटिंग सिस्टम पर चलता है और एक साथ एक हजार से अधिक कनेक्शन के साथ अच्छी तरह से तराजू है। नेटवर्क पार्ट BSD (बर्कले सॉफ्टवेयर डिस्ट्रीब्यूशन) सॉकेट्स का अनुयायी था। टीसीपी (ट्रांसमिशन कंट्रोल प्रोटोकॉल) सॉकेट्स, यूडीपी (यूजर डेटाग्राम प्रोटोकॉल) सॉकेट्स, आईएमसीपी (इंटरनेट कंट्रोल मैसेज प्रोटोकॉल) सॉकेट्स के साथ काम करने के लिए एक एपीआई प्रदान किया जाता है, लाइब्रेरी भी एक्स्टेंसिबल है, इसलिए यदि आप चाहें, तो आप इसे अपने स्वयं के प्रोटोकॉल के लिए अनुकूलित कर सकते हैं। ।

कहानी

2003 में विकास शुरू होने के बाद दिसंबर 2005 में Boost.Asio को Boost 1.35 पर अपनाया गया था। मूल लेखक क्रिस्टोफर एम। कोहलोफ़ हैं, जिन्हें chris@kohlhoff.com पर पहुँचा जा सकता है।
पुस्तकालय का परीक्षण निम्नलिखित प्लेटफार्मों और संकलक पर किया गया है:

• विजुअल C ++ 7.1 और उच्चतर का उपयोग करते हुए 32-बिट और 64-बिट विंडोज
• Windows का उपयोग कर MinGW
• Cygwin का उपयोग करके Windows (सुनिश्चित करें कि __USE_232_SOCKETS परिभाषित है)
• लिनक्स 2.4 और 2.6 कर्नेल पर आधारित g ++ 3.3 और उच्चतर का उपयोग कर रहा है
• जी ++ 3.3 और उच्चतर का उपयोग कर सोलारिस
• मैक ओएस एक्स 10.4+ जी ++ 3.3 और उच्चतर का उपयोग कर

यह AIX 5.3, HP-UX 11i v3, QNX Neutrino 6.3, Solaris जैसे प्लेटफार्मों पर भी काम कर सकता है, Sun Studio 11+, True64 v5.1, Windows, Borland C ++ 5.9.2+ ( www के परामर्श से) का उपयोग कर .boost.org विवरण के लिए)।

पर निर्भर करता है

Boost.Asio निम्नलिखित पुस्तकालयों पर निर्भर करता है:

• Boost.System: यह लाइब्रेरी बूस्ट लाइब्रेरी (http://www.boost.org/doc/libs/1_51_0/doc/html/boost_system/index.html) के लिए ऑपरेटिंग सिस्टम सहायता प्रदान करती है
• Boost.Regex: यदि आप read_until() या read_until() उपयोग करते हैं, तो यह लाइब्रेरी (विकल्प) का उपयोग किया जाता है, जो boost::regex पैरामीटर
• Boost.DateTime: यदि आप Boost.Asio टाइमर का उपयोग करते हैं तो इस लाइब्रेरी (विकल्प) का उपयोग किया जाता है
• OpenSSL: यदि आप Boost.Asio द्वारा प्रदान किए गए SSL समर्थन का उपयोग करने का निर्णय लेते हैं, तो इस लाइब्रेरी (विकल्प) का उपयोग किया जाता है

Buost.Asio बिल्ड

Boost.Asio एक विशुद्ध रूप से हेडर लाइब्रेरी है। हालाँकि, संकलक और आपके कार्यक्रम के आकार के आधार पर, आप स्रोत फ़ाइल के रूप में Boost.Asio बनाने का विकल्प चुन सकते हैं। संकलन समय कम करने के लिए आप ऐसा कर सकते हैं। यह निम्नलिखित तरीकों से किया जा सकता है:

• केवल अपनी फ़ाइलों में से एक में #include <boost/asio/impl/src.hpp> (यदि आप SSL का उपयोग करते हैं, तो #include <boost/asio/ssl/impl/src.hpp> )
• अपने सभी स्रोत फ़ाइलों में #define BOOST_ASIO_SEPARATE_COMPILATION का उपयोग करना

ध्यान दें कि Boost.Asio Boost.System पर निर्भर करता है और Boost.Regex पर जरूरी नहीं है, इसलिए आपको निम्न कोड का उपयोग करके कम से कम एक बढ़ावा पुस्तकालय बनाने की आवश्यकता है:

 bjam –with-system –with-regex stage 

यदि आप भी परीक्षण बनाना चाहते हैं, तो आपको निम्नलिखित कोड का उपयोग करना चाहिए:

 bjam –with-system –with-thread –with-date_time –with-regex –withserialization stage 

पुस्तकालय बहुत सारे उदाहरणों के साथ आता है जिन्हें आप इस पुस्तक में उपलब्ध कराए गए उदाहरणों के साथ देख सकते हैं।

महत्वपूर्ण मैक्रोज़

यदि सेट हो तो BOOST_ASIO_DISABLE_THREADS उपयोग करें; यह Boost.Asio में स्ट्रीम सपोर्ट को निष्क्रिय करता है, भले ही बूस्ट को स्ट्रीम सपोर्ट के साथ संकलित किया गया हो।

एसिंक्रोनस बनाम एसिंक्रोनस

सबसे पहले, अतुल्यकालिक प्रोग्रामिंग सिंक्रोनस प्रोग्रामिंग से बेहद अलग है। सिंक्रोनस प्रोग्रामिंग में, आप सभी ऑपरेशन अनुक्रमिक क्रम में करते हैं, जैसे सॉकेट एस से पढ़ना (अनुरोध), और फिर सॉकेट में लिखना (प्रतिक्रिया)। प्रत्येक ऑपरेशन अवरुद्ध है। चूंकि ऑपरेशन अवरुद्ध हो रहे हैं, इसलिए जब आप सॉकेट में पढ़ रहे हैं या लिख ​​रहे हैं तो मुख्य कार्यक्रम को बाधित नहीं करने के लिए, आप आमतौर पर एक या एक से अधिक थ्रेड बनाते हैं जो इनपुट / आउटपुट सॉकेट्स से निपटते हैं। इस प्रकार, सिंक्रोनस सर्वर / क्लाइंट आमतौर पर मल्टीथ्रेडेड होते हैं।
दूसरी ओर अतुल्यकालिक कार्यक्रम, ईवेंट संचालित होते हैं। आप ऑपरेशन शुरू करते हैं, लेकिन आपको नहीं पता कि यह कब समाप्त होगा; आप एक callback फ़ंक्शन प्रदान करते हैं जिसे ऑपरेशन पूरा होने पर ऑपरेशन के परिणाम के साथ एपीआई द्वारा बुलाया जाएगा। प्रोग्रामर के लिए, जिनके पास क्यूटी के साथ व्यापक अनुभव है, ग्राफिकल यूजर इंटरफेस एप्लिकेशन बनाने के लिए नोकिया के क्रॉस-प्लेटफॉर्म लाइब्रेरी, यह दूसरी प्रकृति है। इस प्रकार, अतुल्यकालिक प्रोग्रामिंग में, आपके पास एक से अधिक थ्रेड होना आवश्यक नहीं है।
आपको अपनी परियोजना के शुरुआती चरण (अधिमानतः शुरुआत में) पर निर्णय लेना चाहिए कि आप किस दृष्टिकोण का उपयोग करेंगे: तुल्यकालिक या अतुल्यकालिक, जैसा कि आधे रास्ते को बदलना मुश्किल और त्रुटि प्रवण होगा; न केवल एपीआई काफी अलग है, आपके प्रोग्राम के शब्दार्थ बहुत बदल जाएंगे (एसिंक्रोनस नेटवर्क आमतौर पर सिंक्रोनस की तुलना में परीक्षण और डिबग करने में अधिक कठिन होते हैं)। इससे पहले कि आप या तो अवरुद्ध कॉल और बहुत सारे थ्रेड्स का उपयोग करना चाहते हैं (तुल्यकालिक आमतौर पर आसान है) या कुछ थ्रेड्स और ईवेंट (असिंक्रोनस आमतौर पर अधिक जटिल है)।
यहाँ एक तुल्यकालिक ग्राहक का एक सरल उदाहरण दिया गया है:

 using boost::asio; io_service service; ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 2001); ip::tcp::socket sock(service); sock.connect(ep); 

सबसे पहले, आपके प्रोग्राम में एक io_service उदाहरण होना चाहिए। Boost.Asio ऑपरेटिंग सिस्टम के I / O सेवा के साथ संचार करने के लिए io_service का उपयोग करता है। आमतौर पर io_service का एक उदाहरण पर्याप्त है। इसके बाद, वह पता और पोर्ट बनाएं, जिसे आप कनेक्ट करना चाहते हैं। एक सॉकेट बनाएं। सॉकेट को अपने पते और पोर्ट से कनेक्ट करें:

 //Here is a simple synchronous server:using boost::asio; typedef boost::shared_ptr<ip::tcp::socket> socket_ptr; io_service service; ip::tcp::endpoint ep( ip::tcp::v4(), 2001)); // listen on 2001 ip::tcp::acceptor acc(service, ep); while ( true) { socket_ptr sock(new ip::tcp::socket(service)); acc.accept(*sock); boost::thread( boost::bind(client_session, sock)); } void client_session(socket_ptr sock) { while ( true) { char data[512]; size_t len = sock->read_some(buffer(data)); if ( len > 0) write(*sock, buffer("ok", 2)); } } 

फिर से, आपके पहले कार्यक्रम में कम से कम एक io_service उदाहरण होना चाहिए। तब आप पोर्ट को सुनने और एक स्वीकर्ता (रिसीवर) बनाने के लिए निर्दिष्ट करते हैं - एक वस्तु जो क्लाइंट कनेक्शन स्वीकार करती है।
अगले लूप में, आप एक डमी सॉकेट बनाते हैं और क्लाइंट के कनेक्ट होने की प्रतीक्षा करते हैं। कनेक्शन स्थापित होने के बाद, आप एक थ्रेड बनाते हैं जो इस कनेक्शन को हैंडल करेगा।
स्ट्रीम में, client_session फ़ंक्शन में client_session आप क्लाइंट अनुरोधों को सुनते हैं, उनकी व्याख्या करते हैं और जवाब देते हैं।
एक साधारण एसिंक्रोनस क्लाइंट बनाने के लिए, आप निम्न के समान कुछ करेंगे:

 using boost::asio; io_service service; ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 2001); ip::tcp::socket sock(service); sock.async_connect(ep, connect_handler); service.run(); void connect_handler(const boost::system::error_code & ec) { // here we know we connected successfully // if ec indicates success } 

आपके प्रोग्राम में कम से कम एक io_service उदाहरण होना चाहिए। आप निर्दिष्ट करते हैं कि सॉकेट कहां से जुड़ा और बनाया गया है। फिर, जैसे ही कनेक्शन स्थापित होता है, आप एसिंक्रोनस रूप से एड्रेस और पोर्ट से जुड़े होते हैं (यह हैंडलर का पूरा होना है), जो कि connect_handler कहलाता है।
connect_handler कॉल करने के बाद connect_handler त्रुटि कोड ( connect_handler जांच करें, और यदि सफल हो, तो आप सर्वर पर अतुल्यकालिक रूप से लिख सकते हैं।
ध्यान दें कि service.run() लूप तब तक निष्पादित होगा जब तक कि अधूरे अतुल्यकालिक ऑपरेशन नहीं होते हैं। पिछले उदाहरण में, केवल एक ही ऑपरेशन है, async_connect सॉकेट। उसके बाद, service.run() समाप्त होता है।
प्रत्येक एसिंक्रोनस ऑपरेशन में एक अनुगामी हैंडलर होता है, एक फ़ंक्शन जिसे ऑपरेशन पूरा होने पर बुलाया जाएगा।
निम्नलिखित कोड एक सरल एसिंक्रोनस सर्वर है:

 using boost::asio; typedef boost::shared_ptr<ip::tcp::socket> socket_ptr; io_service service; ip::tcp::endpoint ep( ip::tcp::v4(), 2001)); // listen on 2001 ip::tcp::acceptor acc(service, ep); socket_ptr sock(new ip::tcp::socket(service)); start_accept(sock); service.run(); void start_accept(socket_ptr sock) { acc.async_accept(*sock, boost::bind( handle_accept, sock, _1) ); } void handle_accept(socket_ptr sock, const boost::system::error_code & err) { if ( err) return; // at this point, you can read/write to the socket socket_ptr sock(new ip::tcp::socket(service)); start_accept(sock); } 

पिछले कोड स्निपेट में, पहले, आप एक io_service उदाहरण बनाते हैं। फिर आप पोर्ट को सुनने के लिए निर्दिष्ट करते हैं। फिर एक ग्राहक - ग्राहक कनेक्शन प्राप्त करने के लिए एक स्वीकारकर्ता बनाएं, साथ ही एक डमी सॉकेट बनाएं और ग्राहक कनेक्शन के लिए प्रतीक्षा करें।
अंत में, अतुल्यकालिक service.run() चलाएं service.run() लूप। जब क्लाइंट कनेक्ट होता है, तो handle_accept ( async_accept को कॉल करने के लिए अंतिम हैंडलर)। यदि कोई त्रुटि नहीं है, तो आप इस सॉकेट का उपयोग पढ़ने / लिखने के संचालन के लिए कर सकते हैं।
सॉकेट का उपयोग करने के बाद, आप एक नया सॉकेट बनाते हैं और फिर से start_accept() कॉल करते हैं, जो एक समान एसिंक्रोनस ऑपरेशन जोड़ता है "ग्राहक कनेक्ट करने के लिए प्रतीक्षा कर रहा है", जिससे service.run() चक्र व्यस्त रहता है।

त्रुटि कोड के अपवाद

Boost.Asio आपको अपवाद और त्रुटि कोड दोनों का उपयोग करने की अनुमति देता है। सभी सिंक्रोनस फ़ंक्शंस में एक त्रुटि के परिणामस्वरूप अपवादों को फेंकने या एक त्रुटि कोड वापस करने का भार होता है। यदि फ़ंक्शन क्रैश हो जाता है, तो यह एक boost::system::system_error त्रुटि।

 using boost::asio; ip::tcp::endpoint ep; ip::tcp::socket sock(service); sock.connect(ep); // Line 1 boost::system::error_code err; sock.connect(ep, err); // Line 2 

पिछले कोड में, sock.connect(ep) एक त्रुटि के मामले में एक अपवाद फेंकता है और sock.connect(ep, err) एक त्रुटि कोड लौटाएगा।
निम्नलिखित कोड स्निपेट पर एक नज़र डालें:

 try { sock.connect(ep); } catch(boost::system::system_error e) { std::cout << e.code() << std::endl; } 

निम्न कोड स्निपेट पिछले एक के समान है:

 boost::system::error_code err; sock.connect(ep, err); if ( err) std::cout << err << std::endl; 

यदि आप अतुल्यकालिक कार्यों का उपयोग करते हैं, तो वे सभी एक त्रुटि कोड देते हैं जिसे आप अपने कॉलबैक फ़ंक्शन में देख सकते हैं। एसिंक्रोनस फ़ंक्शंस अपवादों को कभी नहीं फेंकते हैं और ऐसा करने का कोई मतलब नहीं है। और उसे कौन पकड़ेगा?
अपने सिंक्रोनस फ़ंक्शंस में, आप अपवाद और त्रुटि कोड (जो भी आप अधिक चाहते हैं) दोनों का उपयोग कर सकते हैं, लेकिन एक से अधिक का उपयोग करें। इन्हें मिलाने से समस्या या दुर्घटना हो सकती है (जब आप गलती से अपवाद को भूल जाएं)। यदि आपका कोड जटिल है (सॉकेट को पढ़ने / लिखने के कार्यों को कहा जाता है), तो आप शायद अपवादों का उपयोग करने के लिए बेहतर हैं और एक try {} catch ब्लॉक में रीड एंड राइट कार्य करते हैं।

 void client_session(socket_ptr sock) { try { ... } catch ( boost::system::system_error e) { // handle the error } } 

यदि आप त्रुटि कोड का उपयोग करते हैं, तो आप स्पष्ट रूप से देख सकते हैं कि कनेक्शन कब बंद होगा, जैसा कि निम्नलिखित कोड टुकड़ा में दिखाया गया है:

 char data[512]; boost::system::error_code error; size_t length = sock.read_some(buffer(data), error); if (error == error::eof) return; // Connection closed 

सभी Boost.Asio त्रुटि कोड को boost::asio::error में स्थित हैं boost::asio::error नाम स्थान (यदि आप गलती खोजने के लिए एक पूर्ण खोज करना चाहते हैं)। आप अधिक विवरण के लिए boost/asio/error.hpp भी देख सकते हैं।

Boost.Asio में धाराएँ

जब Boost.Asio में धाराएँ आती हैं, तो हमें निम्नलिखित के बारे में बात करने की आवश्यकता है:

• io_service : io_service वर्ग धागा सुरक्षित है। एकाधिक थ्रेड io_service::run() कह सकते हैं। सबसे अधिक बार, आप शायद एक ही धागे से io_service::run() कहते हैं, इसलिए फ़ंक्शन प्रतीक्षा करता है जब तक कि सभी अवरुद्ध अतुल्यकालिक कार्यों को निष्पादित नहीं किया जाता है। हालाँकि, आप कई थ्रेड्स से io_service::run() कह सकते हैं। यह सभी थ्रेड्स को ब्लॉक करता है जो io_service::run() कॉल करेगा। सभी कॉलबैक फ़ंक्शन को थ्रेड के मील के पत्थरों के संदर्भों में बुलाया जाएगा जिसे io_service::run() कहा जाता है; इसका यह भी अर्थ है कि यदि आप केवल एक धागे में io_service::run() कहते हैं, तो दिए गए धागे के संदर्भ में सभी कॉलबैक फ़ंक्शन को कॉल किया जाएगा।
• socket : socket कक्षाएं थ्रेड सुरक्षित नहीं हैं। इसलिए, आपको एक सॉकेट से एक स्ट्रीम में पढ़ने और इसे दूसरे में लिखने जैसी स्थितियों से बचना चाहिए (यह आमतौर पर अनुशंसित है, Boost.Asio का उल्लेख नहीं करने के लिए)।
• utility : utility वर्ग आमतौर पर कई थ्रेड में उपयोग करने के लिए समझ में नहीं आता है, वे थ्रेड-सुरक्षित नहीं हैं। उनमें से अधिकांश थोड़े समय के लिए उपयोग किए जाते हैं, और फिर दायरे से बाहर जाते हैं।

Boost.Asio लाइब्रेरी में आपके अलावा कई थ्रेड्स का उपयोग किया जा सकता है, लेकिन यह गारंटी है कि इन थ्रेड्स से आपका कोड नहीं कहा जाएगा। बदले में इसका मतलब है कि कॉलबैक फ़ंक्शन केवल उन थ्रेड्स में कहा जाएगा, जहां से io_service::run() कहा जाता है।

नेटवर्क ही नहीं

Boost.Asio नेटवर्क के अलावा अन्य I / O ऑब्जेक्ट प्रदान करता है।
Boost.Asio आपको SIGTERM (प्रोग्राम को समाप्त करना), SIGINT (सिग्नल का व्यवधान), SIGSEGV (सेगमेंट का उल्लंघन) और अन्य जैसे संकेतों का उपयोग करने की अनुमति देता है।
आप signal_set का एक उदाहरण बनाते हैं और निर्दिष्ट करते हैं कि कौन से सिग्नल एसिंक्रोनस रूप से प्रतीक्षा करें और जब उनमें से एक होता है, तो आपका एसिंक्रोनस हैंडलर कहा जाता है:

 void signal_handler(const boost::system::error_code & err, int signal) { // log this, and terminate application } boost::asio::signal_set sig(service, SIGINT, SIGTERM); sig.async_wait(signal_handler); 

यदि SIGINT उत्पन्न होता है, तो आप signal_handler हैंडलर को प्राप्त करेंगे।
Boost.Asio का उपयोग करके, आप आसानी से सीरियल पोर्ट से जुड़ सकते हैं। विंडोज पर COM7 पोर्ट नाम या POSIX प्लेटफॉर्म पर / dev / ttyS0:

 io_service service; serial_port sp(service, "COM7"); 

खोलने के बाद आप कुछ पैरामीटर सेट कर सकते हैं, जैसे पोर्ट डेटा ट्रांसफर रेट, समता, स्टॉप बिट्स, जैसा कि निम्नलिखित कोड टुकड़ा में संकेत दिया गया है:

 serial_port::baud_rate rate(9600); sp.set_option(rate); 

यदि पोर्ट खुला है, तो आप इसे स्ट्रीम में प्रोसेस कर सकते हैं, इसके अलावा, सीरियल पोर्ट को पढ़ने और / या लिखने के लिए नि: शुल्क फ़ंक्शन का उपयोग करने की सिफारिश की जाती है, उदाहरण के लिए, read() , async_read() , write() , async_write() , जैसा कि दिखाया गया है। निम्नलिखित उदाहरण:

 char data[512]; read(sp, buffer(data, 512)); 

Boost.Asio आपको विंडोज़ फ़ाइलों से कनेक्ट करने और फिर से read() , asyn_read() और अन्य जैसे निशुल्क कार्यों का उपयोग करने की अनुमति देता है, जैसा कि नीचे दिखाया गया है:

 HANDLE h = ::OpenFile(...); windows::stream_handle sh(service, h); char data[512]; read(h, buffer(data, 512)); 

आप POSIX फाइल डिस्क्रिप्टर जैसे पाइप, स्टैंडर्ड I / O, विभिन्न डिवाइस (लेकिन नियमित फाइल नहीं) के साथ भी ऐसा कर सकते हैं, जैसा कि निम्नलिखित टुकड़े में किया गया है:

 posix::stream_descriptor sd_in(service, ::dup(STDIN_FILENO)); char data[512]; read(sd_in, buffer(data, 512)); 

टाइमर

कुछ I / O ऑपरेशनों को पूरा करने में समय की कमी हो सकती है। आप इसे केवल अतुल्यकालिक परिचालनों पर लागू कर सकते हैं (चूंकि तुल्यकालिक लॉकिंग का मतलब समय सीमा नहीं है)। उदाहरण के लिए, आपके साथी से निम्न संदेश आपको 100 मिलीसेकंड में आना चाहिए:

 bool read = false; void deadline_handler(const boost::system::error_code &) { std::cout << (read ? "read successfully" : "read failed") << std::endl; } void read_handler(const boost::system::error_code &) { read = true; } ip::tcp::socket sock(service); … read = false; char data[512]; sock.async_read_some(buffer(data, 512)); deadline_timer t(service, boost::posix_time::milliseconds(100)); t.async_wait(&deadline_handler); service.run(); 

पिछले कोड के टुकड़े में, यदि हम समय समाप्त होने से पहले अपना डेटा पढ़ते हैं, तो पढ़ा जाना true , तो हमारा साथी समय पर हमारे पास पहुँच गया। अन्यथा, जब deadline_handler कहा जाता है, तब भी read को false सेट किया जाता false , जिसका अर्थ है कि हमें आवंटित समय के अंत तक संपर्क नहीं किया जाएगा।
Boost.Asio आपको सिंक्रोनस टाइमर का उपयोग करने की अनुमति देता है, लेकिन आमतौर पर वे एक साधारण sleep ऑपरेशन के बराबर होते हैं। लाइन boost::this_thread::sleep(500); और निम्नलिखित स्निपेट ऐसा ही करेंगे:

 deadline_timer t(service, boost::posix_time::milliseconds(500)); t.wait(); 

कक्षा io_service

आपने पहले ही देखा है कि Boost.Asio का उपयोग करने वाले अधिकांश कोड io_service के कुछ उदाहरण का उपयोग करेंगे। io_service लाइब्रेरी में सबसे महत्वपूर्ण वर्ग है, यह ऑपरेटिंग सिस्टम से संबंधित है, सभी अतुल्यकालिक संचालन के अंत की प्रतीक्षा करता है, और फिर पूरा होने पर, ऐसे प्रत्येक ऑपरेशन के लिए एक हैंडलर को बुलाता है।
यदि आप अपना एप्लिकेशन सिंक्रोनस बनाने का निर्णय लेते हैं, तो आपको इस बारे में चिंता करने की आवश्यकता नहीं है कि मैं इस अनुभाग में क्या दिखाने जा रहा हूं।
आप कई तरीकों से io_service उदाहरण का उपयोग कर सकते हैं। निम्नलिखित उदाहरणों में, हमारे पास तीन अतुल्यकालिक संचालन, दो जुड़े सॉकेट और एक प्रतीक्षा टाइमर है:

• एक io_service उदाहरण और एक हैंडलर के साथ एक धागा:
  
  

   io_service service_; // all the socket operations are handled by service_ ip::tcp::socket sock1(service_); // all the socket operations are handled by service_ ip::tcp::socket sock2(service_); sock1.async_connect( ep, connect_handler); sock2.async_connect( ep, connect_handler); deadline_timer t(service_, boost::posix_time::seconds(5)); t.async_wait(timeout_handler); service_.run(); 

  
  
• एक io_service उदाहरण और कई संचालकों के साथ कई सूत्र:
  
  

   io_service service_; ip::tcp::socket sock1(service_); ip::tcp::socket sock2(service_); sock1.async_connect( ep, connect_handler); sock2.async_connect( ep, connect_handler); deadline_timer t(service_, boost::posix_time::seconds(5)); t.async_wait(timeout_handler); for ( int i = 0; i < 5; ++i) boost::thread( run_service); void run_service() { service_.run(); } 

  
  
• io_service और कई संचालकों के कई उदाहरणों के साथ कई सूत्र:
  
  

   io_service service_[2]; ip::tcp::socket sock1(service_[0]); ip::tcp::socket sock2(service_[1]); sock1.async_connect( ep, connect_handler); sock2.async_connect( ep, connect_handler); deadline_timer t(service_[0], boost::posix_time::seconds(5)); t.async_wait(timeout_handler); for ( int i = 0; i < 2; ++i) boost::thread( boost::bind(run_service, i)); void run_service(int idx) { service_[idx].run(); } 

  
  

सबसे पहले, ध्यान दें कि आपके पास एक ही थ्रेड में कई io_service इंस्टेंस नहीं हो सकते हैं। यह निम्नलिखित कोड लिखने के लिए कोई मतलब नहीं है:

 for ( int i = 0; i < 2; ++i) service_[i].run(); 

कोड के पिछले अनुभाग का कोई मतलब नहीं है, क्योंकि service_[1].run() को पहले बंद करते समय service_[0].run() आवश्यकता होगी। इसलिए सभी अतुल्यकालिक service_[1] संचालन को प्रसंस्करण के लिए इंतजार करना होगा, जो एक अच्छा विचार नहीं है।
पिछले सभी तीन उदाहरणों में, हमने तीन अतुल्यकालिक कार्यों के पूरा होने का इंतजार किया। मतभेदों को समझाने के लिए, हम यह मानेंगे कि, कुछ समय बाद, ऑपरेशन 1 समाप्त हो जाएगा और ऑपरेशन 2 उसके तुरंत बाद समाप्त हो जाएगा। हम यह भी मान लेंगे कि प्रत्येक हैंडलर को पूरा करने के लिए एक दूसरे की आवश्यकता है।
पहले मामले में, हम एक धागे में सभी तीन कार्यों के पूरा होने की प्रतीक्षा कर रहे हैं। पहला ऑपरेशन पूरा होने के बाद, हम उसके हैंडलर को बुलाते हैं। यहां तक ​​कि अगर ऑपरेशन 2 पहले के तुरंत बाद समाप्त हो जाता है, तो हम पहले ऑपरेशन के पूरा होने के बाद अपने हैंडलर को कॉल करने के लिए एक सेकंड इंतजार करने के लिए मजबूर होंगे।
दूसरे मामले में, हम दो थ्रेड्स में तीन ऑपरेशन के पूरा होने की प्रतीक्षा कर रहे हैं। पहला ऑपरेशन पूरा होने के बाद, हम इसके हैंडलर को पहले धागे में कहते हैं।जैसे ही ऑपरेशन 2 पूरा हो जाता है, हम तुरंत उसके हैंडलर को दूसरे धागे में कहते हैं (जबकि पहला धागा व्यस्त है, पहले ऑपरेशन को पूरा करने के लिए हैंडलर का इंतजार कर रहा है, दूसरा धागा किसी अन्य ऑपरेशन के पूरा होने पर स्वतंत्र रूप से प्रतिक्रिया दे सकता है)।
बाद के मामले में, यदि ऑपरेशन 1 connectk sock1और ऑपरेशन 2 connectk है sock2, तो अनुप्रयोग दूसरे मामले की तरह व्यवहार करेगा। पहला थ्रेड हैंडलर के connectलिए हैंडल करेगा sock1, और दूसरा धागा हैंडलर के connectलिए हैंडल करेगा sock2। हालांकि, से अगर sock1एक ऑपरेशन 1 और समय समाप्ति deadline_timer tआपरेशन 2 है, पहली धारा हैंडलर पर कार्रवाई करेंगे connectकी sock1। इस प्रकार, टाइमआउट हैंडलर deadline_timer tको काम पूरा करने के लिए हैंडलर का इंतजार करना होगा।connectसे sock1(यह एक सेकंड इंतजार करेगा), पहले थ्रेड में हैंडलर sock1और टाइमआउट हैंडलर दोनों के कनेक्शन की प्रक्रिया होती है t।
यहां आपको पिछले उदाहरणों से सीखना चाहिए:

• बुनियादी अनुप्रयोगों के लिए स्थिति 1। यदि कई हैंडलर को एक ही समय पर कॉल करने की आवश्यकता होती है या यदि उन्हें क्रमिक रूप से कॉल करने की आवश्यकता होती है, तो आप हमेशा समस्याओं में चलेंगे। अगर एक हैंडलर को खत्म होने में लंबा समय लगता है, तो बाकी हैंडलर को इंतजार करना होगा।
• 2 . , . , . , -.
• 3 . , 2 . , (). , - (, io_service::run() ) select/epoll ; , / . , , ( 1000 ). select/epoll .

यदि आपको लगता है कि आपका एप्लिकेशन कभी भी स्थिति 3 पर जाएगा, तो सुनिश्चित करें कि कोड का कोड (कॉल करने वाला कोड io_service::run()) शेष कोड से अलग है ताकि इसे आसानी से बदला जा सके।
अंत में, हमेशा याद रखें कि .run()इसे हमेशा पूरा किया जाएगा यदि नियंत्रण करने के लिए अधिक संचालन नहीं हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

 io_service service_; tcp::socket sock(service_); sock.async_connect( ep, connect_handler); service_.run(); 

इस मामले में, जैसे ही सॉकेट ने एक कनेक्शन स्थापित किया है, इसे कॉल किया जाएगा connect_handlerऔर service.run()समाप्त किया जाएगा।
यदि आप service.run()काम करना जारी रखना चाहते हैं , तो आपको उसे और काम देने चाहिए। इस समस्या को हल करने के दो तरीके हैं। एक तरीका एक connect_handlerऔर अतुल्यकालिक ऑपरेशन चलाकर लोड को बढ़ाने का है ।
दूसरा तरीका निम्नलिखित कोड का उपयोग करके अपने कुछ काम का अनुकरण करना है:

 typedef boost::shared_ptr<io_service::work> work_ptr; work_ptr dummy_work(new io_service::work(service_)); 

इसके बाद के संस्करण कोड एक स्थिर नौकरी प्रदान करेगा service_.run()जब तक आप कॉल नहीं करते useservice_.stop()या dummy_work.reset(0); // destroy dummy_work।

सारांश।

Boost.Asio एक परिष्कृत पुस्तकालय है जो नेटवर्क प्रोग्रामिंग को बहुत आसान बनाता है। इसे इकट्ठा करना आसान है। यह काफी अच्छी तरह से काम करता है, मैक्रोज़ के उपयोग से बचता है; कई मैक्रोज़ को चालू / बंद विकल्पों को सक्षम करने के लिए प्रदान किया जाता है, लेकिन कुछ चीजें हैं जिनके बारे में आपको नहीं भूलना चाहिए।
Boost.Asio सिंक्रोनस और एसिंक्रोनस प्रोग्रामिंग का समर्थन करता है। ये दो दृष्टिकोण बहुत अलग हैं और आपको यथासंभव एक का चयन करना चाहिए, क्योंकि स्विचिंग काफी जटिल है और त्रुटि प्रवण है।
यदि आपने तुल्यकालिक दृष्टिकोण को चुना है, तो आप अपवादों और त्रुटि कोडों के बीच चयन कर सकते हैं, अपवादों से त्रुटि कोडों तक संक्रमण काफी सरल है, आपको फ़ंक्शन कॉल (त्रुटि कोड) में एक और तर्क जोड़ने की आवश्यकता है।
Boost.Asio केवल प्रोग्रामिंग नेटवर्क के लिए नहीं है। इस लाइब्रेरी में कई विशेषताएं हैं जो इसे और अधिक मूल्यवान बनाती हैं, जैसे सिग्नल, टाइमर और इसी तरह।
अगले अध्याय में, हम Boost.Asio के कई कार्यों और कक्षाओं में तल्लीन करेंगे जो नेटवर्क प्रदान करते हैं। इसके अलावा, हम अतुल्यकालिक प्रोग्रामिंग के बारे में कुछ गुर सीखेंगे।

खैर, यह सब आज के लिए है, अगर आपको यह पसंद आया, तो मैं ख़ुशी से अनुवाद जारी रखूंगा। सभी टिप्पणियों के लिए, टिप्पणियों में लिखें।

सभी को शुभकामनाएँ!