"Boost.Asio C ++ नेटवर्क प्रोग्रामिंग।" अध्याय 4: क्लाइंट और सर्वर

सभी को नमस्कार!
मैं जॉन टोरजो की पुस्तक Boost.Asio C ++ नेटवर्क प्रोग्रामिंग का अनुवाद करना जारी रखता हूं।

सामग्री:

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

इस अध्याय में, हम Boost.Asio का उपयोग करके गैर-तुच्छ क्लाइंट / सर्वर एप्लिकेशन बनाने में गहराई से जा रहे हैं। आप उन्हें चला सकते हैं और उनका परीक्षण कर सकते हैं, और एक बार जब आप उन्हें समझ जाते हैं, तो आप उन्हें अपने स्वयं के अनुप्रयोगों को बनाने के लिए एक आधार के रूप में उपयोग कर सकते हैं।


निम्नलिखित अनुप्रयोगों में:

• क्लाइंट एक उपयोगकर्ता नाम (कोई पासवर्ड नहीं) के साथ सर्वर पर लॉग इन करता है
• सभी कनेक्शन क्लाइंट द्वारा शुरू किए जाते हैं, जहां क्लाइंट सर्वर से प्रतिक्रिया का अनुरोध करता है
• उनके लिए सभी अनुरोध और प्रतिक्रियाएं चरित्र '\ n' के साथ समाप्त होती हैं
• सर्वर किसी भी क्लाइंट को डिस्कनेक्ट करता है जो 5 सेकंड के भीतर जवाब नहीं देता है

ग्राहक निम्नलिखित अनुरोध कर सकते हैं:

• सभी जुड़े ग्राहकों की एक सूची प्राप्त करें
• क्लाइंट पिंग कर सकता है, और जब यह सर्वर को ping_ok या ping client_list_chaned करने के लिए क्लाइंट को ping client_list_chaned (बाद वाले मामले में, क्लाइंट कनेक्टेड क्लाइंट की सूची का पुनः अनुरोध करता है)।

मनोरंजन के लिए, कुछ ट्रिक्स जोड़ें:

• प्रत्येक क्लाइंट एप्लिकेशन में 6 कनेक्ट किए गए उपयोगकर्ता शामिल हैं, जैसे जॉन, जेम्स, लुसी, ट्रेसी फ्रैंक और एबी।
• प्रत्येक क्लाइंट सर्वर के साथ एक यादृच्छिक समय पर कनेक्शन की जांच करता है (प्रत्येक 1-7 सेकंड में एक बार, इसलिए समय-समय पर सर्वर के साथ कनेक्शन काट दिया जाएगा)

सिंक्रोनस सर्वर / क्लाइंट

सबसे पहले, हम एक तुल्यकालिक अनुप्रयोग को लागू करते हैं। आप देखेंगे कि कोड सरल और सीखने में आसान है। हालाँकि, नेटवर्क भाग को एक अलग थ्रेड में किया जाना चाहिए, क्योंकि सभी नेटवर्क कॉल अवरुद्ध हैं।

तुल्यकालिक ग्राहक

तुल्यकालिक ग्राहक, जैसा कि आप की उम्मीद थी, सब कुछ क्रमिक रूप से करता है; सर्वर से जुड़ता है, उस पर लॉग करता है, और फिर एक संचार चक्र करता है, अर्थात् सो जाते हैं, एक अनुरोध करते हैं, सर्वर की प्रतिक्रिया पढ़ते हैं, फिर से सो जाते हैं और इसी तरह।



चूंकि हम एक तुल्यकालिक संस्करण कर रहे हैं, यह हमें कुछ चीजों को सरल बनाने की अनुमति देता है। सबसे पहले, सर्वर से कनेक्ट करें; चलो इसे एक लूप में करते हैं, उदाहरण के लिए, इस तरह:

 ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 8001); void run_client(const std::string & client_name) { talk_to_svr client(client_name); try { client.connect(ep); client.loop(); } catch(boost::system::system_error & err) { std::cout << "client terminated " << std::endl; } } 

निम्न उदाहरण talk_to_svr वर्ग है:

 struct talk_to_svr { talk_to_svr(const std::string & username): sock_(service), started_(true), username_(username) {} void connect(ip::tcp::endpoint ep) { sock_.connect(ep); } void loop() { write("login " + username_ + "\n"); read_answer(); while ( started_) { write_request(); read_answer(); boost::this_thread::sleep(millisec(rand() % 7000)); } } std::string username() const { return username_; } ... private: ip::tcp::socket sock_; enum { max_msg = 1024 }; int already_read_; char buff_[max_msg]; bool started_; std::string username_; }; 

लूप में, हम सिर्फ प्रतिक्रिया करते हैं, सर्वर से प्रतिक्रिया पढ़ते हैं और सो जाते हैं। हम अनिश्चित समय के लिए सो जाते हैं (कभी-कभी 5 सेकंड से अधिक), इसलिए कुछ बिंदु पर सर्वर हमें बंद कर देगा:

 void write_request() { write("ping\n"); } void read_answer() { already_read_ = 0; read(sock_, buffer(buff_), boost::bind(&talk_to_svr::read_complete, this, _1, _2)); process_msg(); } void process_msg() { std::string msg(buff_, already_read_); if ( msg.find("login ") == 0) on_login(); else if ( msg.find("ping") == 0) on_ping(msg); else if ( msg.find("clients ") == 0) on_clients(msg); else std::cerr << "invalid msg " << msg << std::endl; } 

उत्तर पढ़ने के लिए, हम यह सुनिश्चित करने के लिए read_complete (जिसका पिछले अध्याय में बहुत चर्चा की गई) का उपयोग करते हैं कि हम चरित्र '\ n' तक पढ़ते हैं। तर्क process_msg() फ़ंक्शन में निहित है, जहां हम क्लाइंट की प्रतिक्रिया पढ़ते हैं और इसे सही फ़ंक्शन पर निर्देशित करते हैं:

 void on_login() { do_ask_clients(); } void on_ping(const std::string & msg) { std::istringstream in(msg); std::string answer; in >> answer >> answer; if ( answer == "client_list_changed") do_ask_clients(); } void on_clients(const std::string & msg) { std::string clients = msg.substr(8); std::cout << username_ << ", new client list:" << clients; } void do_ask_clients() { write("ask_clients\n"); read_answer(); } void write(const std::string & msg) { sock_.write_some(buffer(msg)); } size_t read_complete(const boost::system::error_code & err, size_t bytes) { // ... same as before } 

हमारे पिंग में सर्वर से प्रतिक्रिया को पढ़ने पर, अगर हमें client_list_changed मिलता है, तो हम फिर से ग्राहकों की एक सूची प्राप्त करने के लिए अनुरोध करते हैं।

सिंक्रोनस सर्वर

सिंक्रोनस सर्वर भी काफी सरल है। इसे दो धागे की जरूरत है, एक नए ग्राहकों को सुनने के लिए, दूसरा मौजूदा को संभालने के लिए। यह एक थ्रेड का उपयोग नहीं कर सकता है, एक नए क्लाइंट की प्रतीक्षा करना एक अवरुद्ध ऑपरेशन है, इसलिए हमें मौजूदा क्लाइंट को संसाधित करने के लिए एक अतिरिक्त थ्रेड की आवश्यकता है।



जैसा कि अपेक्षित था, क्लाइंट लिखने की तुलना में सर्वर लिखना थोड़ा अधिक जटिल है। एक ओर, यह सभी जुड़े हुए ग्राहकों का प्रबंधन करना चाहिए। चूंकि हम सर्वर का एक तुल्यकालिक संस्करण लिख रहे हैं, हमें कम से कम दो थ्रेड्स की आवश्यकता होती है, जिनमें से एक नए क्लाइंट को स्वीकार करता है (क्योंकि accept() अवरुद्ध ऑपरेशन है), और दूसरा मौजूदा लोगों के लिए जिम्मेदार है:

 void accept_thread() { ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(), 8001)); while ( true) { client_ptr new_( new talk_to_client); acceptor.accept(new_->sock()); boost::recursive_mutex::scoped_lock lk(cs); clients.push_back(new_); } } void handle_clients_thread() { while ( true) { boost::this_thread::sleep( millisec(1)); boost::recursive_mutex::scoped_lock lk(cs); for(array::iterator b = clients.begin(),e = clients.end(); b != e; ++b) (*b)->answer_to_client(); // erase clients that timed out clients.erase(std::remove_if(clients.begin(), clients.end(), boost::bind(&talk_to_client::timed_out,_1)), clients.end()); } } int main(int argc, char* argv[]) { boost::thread_group threads; threads.create_thread(accept_thread); threads.create_thread(handle_clients_thread); threads.join_all(); } 

हमें उनसे आने वाले अनुरोधों को संसाधित करने के लिए ग्राहकों की एक सूची की आवश्यकता है।
talk_to_client प्रत्येक उदाहरण में एक सॉकेट है। इसमें एक कॉपी कंस्ट्रक्टर नहीं है, इसलिए यदि आप इसे std::vector में रटना चाहते हैं, तो आपको इस पर एक साझा पॉइंटर रखने की आवश्यकता है। ऐसा करने के दो तरीके हैं: या तो talk_to_client अंदर सॉकेट पर एक साझा पॉइंटर मिलता है, और फिर talk_to_client इंस्टेंस की एक सरणी बनाते हैं या जब एक सॉकेट के साथ एक talk_to_client उदाहरण होता है और Talk_to_client पर साझा पॉइंटर्स की एक सरणी डालते हैं। मैंने बाद को चुना, लेकिन आप दूसरे तरीके से जा सकते हैं:

 typedef boost::shared_ptr<talk_to_client> client_ptr; typedef std::vector<client_ptr> array; array clients; boost::recursive_mutex cs; // thread-safe access to clients array 

मुख्य talk_to_client कोड निम्नानुसार है:

 struct talk_to_client : boost::enable_shared_from_this<talk_to_client> { talk_to_client() { ... } std::string username() const { return username_; } void answer_to_client() { try { read_request(); process_request(); } catch ( boost::system::system_error&) { stop(); } if ( timed_out()) stop(); } void set_clients_changed() { clients_changed_ = true; } ip::tcp::socket & sock() { return sock_; } bool timed_out() const { ptime now = microsec_clock::local_time(); long long ms = (now - last_ping).total_milliseconds(); return ms > 5000 ; } void stop() { boost::system::error_code err; sock_.close(err); } void read_request() { if ( sock_.available()) already_read_ += sock_.read_some( buffer(buff_ + already_read_, max_msg - already_read_)); } ... private: // ... same as in Synchronous Client bool clients_changed_; ptime last_ping; }; 

उपरोक्त कोड बहुत स्पष्ट है। सबसे महत्वपूर्ण कार्य read_request() । डेटा होने पर ही रीडिंग होगी, इसलिए सर्वर कभी ब्लॉक नहीं होगा:

 void process_request() { bool found_enter = std::find(buff_, buff_ + already_read_, '\n') < buff_ + already_read_; if ( !found_enter) return; // message is not full // process the msg last_ping = microsec_clock::local_time(); size_t pos = std::find(buff_, buff_ + already_read_, '\n') - buff_; std::string msg(buff_, pos); std::copy(buff_ + already_read_, buff_ + max_msg, buff_); already_read_ -= pos + 1; if ( msg.find("login ") == 0) on_login(msg); else if ( msg.find("ping") == 0) on_ping(); else if ( msg.find("ask_clients") == 0) on_clients(); else std::cerr << "invalid msg " << msg << std::endl; } void on_login(const std::string & msg) { std::istringstream in(msg); in >> username_ >> username_; write("login ok\n"); update_clients_changed(); } void on_ping() { write(clients_changed_ ? "ping client_list_changed\n" : "ping ok\n"); clients_changed_ = false; } void on_clients() { std::string msg; { boost::recursive_mutex::scoped_lock lk(cs); for( array::const_iterator b = clients.begin(), e = clients.end() ;b != e; ++b) msg += (*b)->username() + " "; } write("clients " + msg + "\n"); } void write(const std::string & msg) { sock_.write_some(buffer(msg)); } 

process_request() पर एक नज़र डालें। जब हम उपलब्ध डेटा को पढ़ते हैं, तो हमें यह जांचना चाहिए कि क्या हम संदेश को अंत तक found_enteris (यदि ऐसा है, तो found_enteris को सही पर सेट किया found_enteris )। यदि यह मामला है, तो हम खुद को पढ़ने से बचाते हैं, शायद एक से अधिक संदेश ('n' वर्ण के बाद बफर में कुछ भी नहीं बचाया जाएगा), और फिर हम पूरी तरह से पढ़े गए संदेश की व्याख्या करते हैं। बाकी कोड बहुत सरल है।

अतुल्यकालिक सर्वर / क्लाइंट

और अब सबसे दिलचस्प (और कठिन) भाग के लिए, आइए अतुल्यकालिक रूप से चलते हैं।

अतुल्यकालिक ग्राहक

चीजों को अब थोड़ा अधिक जटिल माना जाएगा, लेकिन निश्चित रूप से प्रबंधनीय। और हमारे पास एक एप्लिकेशन होगा जो ब्लॉक नहीं करता है।



आपको पहले से ही निम्न कोड को समझना चाहिए:

 #define MEM_FN(x) boost::bind(&self_type::x, shared_from_this()) #define MEM_FN1(x,y) boost::bind(&self_type::x, shared_from_this(),y) #define MEM_FN2(x,y,z) boost::bind(&self_type::x, shared_from_this(),y,z) class talk_to_svr : public boost::enable_shared_from_this<talk_to_svr>, boost::noncopyable { typedef talk_to_svr self_type; talk_to_svr(const std::string & username) : sock_(service), started_(true), username_(username), timer_(service) {} void start(ip::tcp::endpoint ep) { sock_.async_connect(ep, MEM_FN1(on_connect,_1)); } public: typedef boost::system::error_code error_code; typedef boost::shared_ptr<talk_to_svr> ptr; static ptr start(ip::tcp::endpoint ep, const std::string & username) { ptr new_(new talk_to_svr(username)); new_->start(ep); return new_; } void stop() { if ( !started_) return; started_ = false; sock_.close(); } bool started() { return started_; } ... private: size_t read_complete(const boost::system::error_code & err, size_t bytes) { if ( err) return 0; bool found = std::find(read_buffer_, read_buffer_ + bytes, '\n') < read_buffer_ + bytes; return found ? 0 : 1; } private: ip::tcp::socket sock_; enum { max_msg = 1024 }; char read_buffer_[max_msg]; char write_buffer_[max_msg]; bool started_; std::string username_; deadline_timer timer_; }; 

आपको सर्वर को पिंग करने के लिए एक अतिरिक्त deadline_timer सीमा_टाइमर टाइमर फ़ंक्शन दिखाई देगा; और फिर, हम समय पर एक यादृच्छिक बिंदु पर सर्वर के साथ कनेक्शन की जांच करेंगे।
खैर, अब देखते हैं कि कक्षा का मुख्य तर्क कैसा दिखता है:

 void on_connect(const error_code & err) { if ( !err) do_write("login " + username_ + "\n"); else stop(); } void on_read(const error_code & err, size_t bytes) { if ( err) stop(); if ( !started() ) return; // process the msg std::string msg(read_buffer_, bytes); if ( msg.find("login ") == 0) on_login(); else if ( msg.find("ping") == 0) on_ping(msg); else if ( msg.find("clients ") == 0) on_clients(msg); } void on_login() { do_ask_clients(); } void on_ping(const std::string & msg) { std::istringstream in(msg); std::string answer; in >> answer >> answer; if ( answer == "client_list_changed") do_ask_clients(); else postpone_ping(); } void on_clients(const std::string & msg) { std::string clients = msg.substr(8); std::cout << username_ << ", new client list:" << clients ; postpone_ping(); } 

on_read() में कोड की पहली दो पंक्तियों में सब कुछ बहुत खूबसूरती से किया जाता है। पहली पंक्ति में हम जांचते हैं कि क्या कोई त्रुटि है, यदि ऐसा है, तो रुकें। दूसरी पंक्ति में हम जांचते हैं कि क्या हम (उससे पहले या बस) रुक गए, यदि ऐसा है, तो हम वापस लौटते हैं। अन्यथा, यदि सब कुछ ठीक है, तो हम आने वाले संदेश को संसाधित करते हैं।
अंत में, do_* फ़ंक्शन निम्नानुसार हैं:

 void do_ping() { do_write("ping\n"); } void postpone_ping() { timer_.expires_from_now(boost::posix_time::millisec(rand() % 7000)); timer_.async_wait( MEM_FN(do_ping)); } void do_ask_clients() { do_write("ask_clients\n"); } void on_write(const error_code & err, size_t bytes) { do_read(); } void do_read() { async_read(sock_, buffer(read_buffer_), MEM_FN2(read_complete,_1,_2), MEM_FN2(on_read,_1,_2)); } void do_write(const std::string & msg) { if ( !started() ) return; std::copy(msg.begin(), msg.end(), write_buffer_); sock_.async_write_some( buffer(write_buffer_, msg.size()), MEM_FN2(on_write,_1,_2)); } 

ध्यान दें कि प्रत्येक read ऑपरेशन पिंग का कारण बनता है:

• जब read ऑपरेशन पूरा हो जाता है, तो on_read()
• on_read() on_login(), on_ping() , या on_clients() पुनर्निर्देशित किया गया है
• प्रत्येक फ़ंक्शंस या तो क्लाइंट्स को पिंग या पोस्टपोन करता है
• यदि हम क्लाइंट से पूछते हैं कि रीड ऑपरेशन कब हुआ है, तो यह पिंग में देरी करेगा

अतुल्यकालिक सर्वर

यह योजना काफी जटिल है, आप देखते हैं कि चार तीर Boost.Asio से on_accept, on_read, on_write और on_check_ping से दूर जा रहे हैं। मूल रूप से, इसका मतलब है कि आप कभी भी कॉल से नहीं पहचान पाएंगे कि इन अतुल्यकालिक ऑपरेशनों में से कौन सा सब कुछ समाप्त हो जाएगा, लेकिन आप यह सुनिश्चित करने के लिए जानते हैं कि यह उनमें से एक होगा।



इसलिए, हम एसिंक्रोनस रूप से काम करते हैं, इसलिए हम एक धागे में काम कर सकते हैं। ग्राहकों का स्वागत सबसे आसान हिस्सा है, जैसा कि निम्नलिखित कोड टुकड़ा में दिखाया गया है:

 ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(), 8001)); void handle_accept(talk_to_client::ptr client, const error_code & err) { client->start(); talk_to_client::ptr new_client = talk_to_client::new_(); acceptor.async_accept(new_client->sock(), boost::bind(handle_accept,new_client,_1)); } int main(int argc, char* argv[]) { talk_to_client::ptr client = talk_to_client::new_(); acceptor.async_accept(client->sock(), boost::bind(handle_accept,client,_1)); service.run(); } 

उपरोक्त कोड हमेशा नए ग्राहकों के लिए अतुल्यकालिक रूप से प्रतीक्षा करेगा (प्रत्येक नया ग्राहक कनेक्शन एक और अतुल्यकालिक प्रतीक्षा का कारण बनेगा)।
हमें client list changed घटना की निगरानी करनी चाहिए (एक नया ग्राहक जुड़ा हुआ है या ग्राहकों में से एक सूची प्राप्त और डिस्कनेक्ट किया गया है) और ऐसा होने पर अन्य ग्राहकों को सूचित करें। इस प्रकार, हमें ग्राहकों की एक सरणी को संग्रहित करना होगा, अन्यथा इस सरणी की कोई आवश्यकता नहीं होगी यदि आप किसी निश्चित समय में सभी जुड़े हुए ग्राहकों को जानना नहीं चाहेंगे:

 class talk_to_client; typedef boost::shared_ptr<talk_to_client> client_ptr; typedef std::vector<client_ptr> array; array clients; 

connection वर्ग का कंकाल निम्नानुसार है:

 class talk_to_client : public boost::enable_shared_from_this<talk_to_ client>, boost::noncopyable { talk_to_client() { ... } public: typedef boost::system::error_code error_code; typedef boost::shared_ptr<talk_to_client> ptr; void start() { started_ = true; clients.push_back( shared_from_this()); last_ping = boost::posix_time::microsec_clock::local_time(); do_read(); // first, we wait for client to login } static ptr new_() { ptr new_(new talk_to_client); return new_; } void stop() { if ( !started_) return; started_ = false; sock_.close(); ptr self = shared_from_this(); array::iterator it = std::find(clients.begin(), clients.end(), self); clients.erase(it); update_clients_changed(); } bool started() const { return started_; } ip::tcp::socket & sock() { return sock_;} std::string username() const { return username_; } void set_clients_changed() { clients_changed_ = true; } ... private: ip::tcp::socket sock_; enum { max_msg = 1024 }; char read_buffer_[max_msg]; char write_buffer_[max_msg]; bool started_; std::string username_; deadline_timer timer_; boost::posix_time::ptime last_ping; bool clients_changed_; }; 

मैं connection वर्ग से talk_to_client या talk_to_server को कॉल करता talk_to_client जो मैं कह रहा हूं स्पष्ट करने के लिए।
अब हमें पिछले कोड का उपयोग करना होगा; यह क्लाइंट एप्लिकेशन के लिए हमारे द्वारा उपयोग किए जाने के समान है। हमारे पास एक अतिरिक्त stop() फ़ंक्शन है जो क्लाइंट सरणी से कनेक्ट किए गए क्लाइंट को निकालता है।
सर्वर लगातार अतुल्यकालिक पढ़ने के संचालन की प्रतीक्षा करता है:

 void on_read(const error_code & err, size_t bytes) { if ( err) stop(); if ( !started() ) return; std::string msg(read_buffer_, bytes); if ( msg.find("login ") == 0) on_login(msg); else if ( msg.find("ping") == 0) on_ping(); else if ( msg.find("ask_clients") == 0) on_clients(); } void on_login(const std::string & msg) { std::istringstream in(msg); in >> username_ >> username_; do_write("login ok\n"); update_clients_changed(); } void on_ping() { do_write(clients_changed_ ? "ping client_list_changed\n" : "ping ok\n"); clients_changed_ = false; } void on_clients() { std::string msg; for(array::const_iterator b =clients.begin(),e =clients.end(); b != e; ++b) msg += (*b)->username() + " "; do_write("clients " + msg + "\n"); } 

कोड बहुत सरल है; एक बात यह है कि जब कोई नया क्लाइंट लॉग इन करता है, तो हम update_clients_changed() कॉल update_clients_changed() , जो सभी ग्राहकों के लिए clients_changed_ को true सेट करता है।
जैसे ही उसे कोई अनुरोध मिलता है, वह तुरंत इसका उत्तर देता है, जैसा कि निम्नलिखित कोड टुकड़ा में दिखाया गया है:

 void do_ping() { do_write("ping\n"); } void do_ask_clients() { do_write("ask_clients\n"); } void on_write(const error_code & err, size_t bytes) { do_read(); } void do_read() { async_read(sock_, buffer(read_buffer_), MEM_FN2(read_complete,_1,_2), MEM_FN2(on_read,_1,_2)); post_check_ping(); } void do_write(const std::string & msg) { if ( !started() ) return; std::copy(msg.begin(), msg.end(), write_buffer_); sock_.async_write_some( buffer(write_buffer_, msg.size()), MEM_FN2(on_write,_1,_2)); } size_t read_complete(const boost::system::error_code & err, size_t bytes) { // ... as before } 

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

 void on_check_ping() { ptime now = microsec_clock::local_time(); if ( (now - last_ping).total_milliseconds() > 5000) stop(); last_ping = boost::posix_time::microsec_clock::local_time(); } void post_check_ping() { timer_.expires_from_now(boost::posix_time::millisec(5000)); timer_.async_wait( MEM_FN(on_check_ping)); } 

वह पूरा सर्वर है। आप इसे शुरू कर सकते हैं और इसके साथ काम करना शुरू कर सकते हैं!

सारांश

इस अध्याय में, हमने कुछ बुनियादी क्लाइंट / सर्वर एप्लिकेशन को लिखने का तरीका देखा। हम स्मृति लीक और गतिरोध जैसे जाल से बच गए। सभी कार्यक्रम आपके भविष्य के अनुप्रयोगों के लिए एक आधार के रूप में उपयुक्त हैं, उन्हें विस्तारित और अनुकूलित किया जा सकता है।
अगले अध्याय में, हम Boost.Asio का उपयोग करते समय सिंक्रोनस बनाम अतुल्यकालिक, अंतर की गहरी समझ प्राप्त करेंगे; देखें कि आप अपने स्वयं के अतुल्यकालिक ऑपरेशन को कैसे कनेक्ट कर सकते हैं।

इस लेख के लिए संसाधन: लिंक

ध्यान देने के लिए आप सभी का धन्यवाद, जल्द ही मिलते हैं!