C++ पर WebSocket: उन्नत स्तर के रियल-टाइम एप्लिकेशन

C++ पर WebSocket: उच्च-प्रदर्शन वाले रियल-टाइम एप्लिकेशन बनाना

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

हम आर्किटेक्चरल समाधानों पर ध्यान केंद्रित करेंगे जो दसियों हज़ार समवर्ती कनेक्शनों को संभालने में सक्षम बनाते हैं, और लोकप्रिय लाइब्रेरीज़ का उपयोग करके विशिष्ट कोड उदाहरणों का विश्लेषण करेंगे।

1. लाइब्रेरी का चयन और प्रोजेक्ट सेटअप

प्रोडक्शन-ग्रेड C++ डेवलपमेंट के लिए दो मुख्य दृष्टिकोण हैं: उच्च-स्तरीय लाइब्रेरी uWebSockets (uWS) या निम्न-स्तरीय संयोजन Boost.Asio + Boost.Beast का उपयोग करना। पहला विकल्प सरल है, दूसरा पूर्ण नियंत्रण प्रदान करता है।

Boost.Beast (Asio पर आधारित) उन परियोजनाओं के लिए उद्योग मानक है जहाँ हर माइक्रोसेकंड मायने रखता है। आइए एक एसिंक्रोनस WebSocket सर्वर की मूल संरचना देखें:

#include <boost/beast/core.hpp>#include <boost/beast/websocket.hpp>#include <boost/asio.hpp>#include <memory>#include <string>

namespace beast = boost::beast;namespace websocket = beast::websocket;namespace net = boost::asio;using tcp = net::ip::tcp;

// एक कनेक्शन को संभालने के लिए क्लासclass WebSocketSession : public std::enable_shared_from_this<WebSocketSession> {    websocket::stream<beast::tcp_stream> ws_;    beast::flat_buffer buffer_;public:    explicit WebSocketSession(tcp::socket&& socket)        : ws_(std::move(socket)) {}

    void run() {        // एसिंक्रोनस रूप से WebSocket हैंडशेक स्वीकार करें        ws_.async_accept(            beast::bind_front_handler(&WebSocketSession::on_accept, shared_from_this()));    }

    void on_accept(beast::error_code ec) {        if(!ec) {            // स्वागत संदेश भेजें            ws_.async_write(                net::buffer(std::string("रियल-टाइम दुनिया में आपका स्वागत है!")),                beast::bind_front_handler(&WebSocketSession::on_write, shared_from_this()));            do_read();        }    }    // ... (नीचे जारी)};

मुख्य बिंदु: प्रत्येक क्लाइंट को WebSocketSession का अपना इंस्टेंस मिलता है, जो एसिंक्रोनस मोड में काम करता है। यह डेटा की प्रतीक्षा करते समय मुख्य थ्रेड को ब्लॉक नहीं होने देता।

2. थ्रेड पूल के साथ मल्टीथ्रेडेड सर्वर आर्किटेक्चर

एकल io_context थ्रेड CPU सीमा तक पहुँच जाता है। हज़ारों कनेक्शनों तक स्केल करने के लिए थ्रेड पूल का उपयोग करें। प्रत्येक थ्रेड अपना स्वयं का io_context इंस्टेंस चलाता है, और कनेक्शन accept-बैलेंसिंग के माध्यम से वितरित किए जाते हैं।

void run_server(const std::string& address, unsigned short port, int thread_count) {    net::io_context ioc{thread_count}; // थ्रेड्स की संख्या निर्दिष्ट करते हुए io_context बनाएं

    tcp::acceptor acceptor{ioc, {net::ip::make_address(address), port}};

    // लूप में accept चलाएं    std::function<void()> do_accept = [&]() {        acceptor.async_accept(            [&](beast::error_code ec, tcp::socket socket) {                if (!ec) {                    // एक सत्र बनाएं और इसे सॉकेट दें                    std::make_shared<WebSocketSession>(std::move(socket))->run();                }                do_accept(); // स्वीकार करना जारी रखें            });    };    do_accept();

    // थ्रेड पूल चलाएं    std::vector<std::thread> threads;    for (int i = 0; i < thread_count; ++i) {        threads.emplace_back([&ioc]() { ioc.run(); });    }

    for (auto& t : threads) t.join();}

महत्वपूर्ण