WebSocket на C++: real-time приложения продвинутого уровня

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Введение: Почему WebSocket на C++ — выбор профессионалов для real-time систем

В современном мире real-time коммуникаций — от биржевых терминалов до многопользовательских игр — задержка в миллисекунды решает всё. WebSocket на C++ позволяет достичь производительности, недоступной интерпретируемым языкам. В этой статье мы разберём продвинутые техники создания real-time приложений на C++ с использованием библиотеки Boost.Beast, которая предоставляет низкоуровневый контроль над протоколом и минимальные накладные расходы.

Мы не будем рассматривать основы — предполагается, что вы знакомы с сетевым программированием на C++ и основами WebSocket. Вместо этого сфокусируемся на архитектуре, масштабировании, обработке ошибок и оптимизации производительности.

Архитектура асинхронного WebSocket сервера на C++ с Boost.Beast

Ключевое преимущество C++ — возможность построения полностью асинхронных систем без накладных расходов на потоки. Boost.Beast построен поверх Boost.Asio, что даёт мощный инструментарий для работы с сетевыми сокетами.

Базовая структура сервера

Сервер должен уметь обрабатывать тысячи одновременных подключений. Для этого используется event loop (io_context) и асинхронные операции. Рассмотрим минимальную, но продвинутую реализацию:

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

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() {
        // Асинхронный handshake
        ws_.async_accept(
            beast::bind_front_handler(
                &WebSocketSession::on_accept,
                shared_from_this()));
    }

private:
    void on_accept(beast::error_code ec) {
        if (ec) return;
        do_read();
    }

    void do_read() {
        ws_.async_read(buffer_,
            beast::bind_front_handler(
                &WebSocketSession::on_read,
                shared_from_this()));
    }

    void on_read(beast::error_code ec, std::size_t bytes_transferred) {
        if (ec == websocket::error::closed) return;
        if (ec) return;

        // Обработка сообщения
        std::string msg = beast::buffers_to_string(buffer_.data());
        buffer_.consume(buffer_.size());

        // Эхо-ответ (в реальном приложении - бизнес-логика)
        ws_.text(ws_.got_text());
        ws_.async_write(net::buffer(msg),
            beast::bind_front_handler(
                &WebSocketSession::on_write,
                shared_from_this()));
    }

    void on_write(beast::error_code ec, std::size_t bytes_transferred) {
        if (ec) return;
        do_read();
    }
};

Управление сессиями и широковещательная рассылка

Для real-time чата или мониторинга требуется отправлять сообщения всем подключённым клиентам. Используем thread-safe контейнер:

class WebSocketServer {
    net::io_context& ioc_;
    tcp::acceptor acceptor_;
    std::unordered_set<std::shared_ptr<WebSocketSession>> sessions_;
    std::mutex sessions_mutex_;

public:
    WebSocketServer(net::io_context& ioc, short port)
        : ioc_(ioc)
        , acceptor_(ioc, tcp::endpoint(tcp::v4(), port)) {
        do_accept();
    }

    void broadcast(const std::string& message) {
        std::lock_guard<std::mutex> lock(sessions_mutex_);
        for (auto& session : sessions_) {
            session->send(message);
        }
    }

private:
    void do_accept() {
        acceptor_.async_accept(
            [this](beast::error_code ec, tcp::socket socket) {
                if (!ec) {
                    auto session = std::make_shared<WebSocketSession>(std::move(socket));
                    {
                        std::lock_guard<std::mutex> lock(sessions_mutex_);
                        sessions_.insert(session);
                    }
                    session->run();
                }
                do_accept();
            });
    }
};

Продвинутая обработка ошибок и восстановление соединения

В real-time системах разрыв соединения — не исключение, а норма. Необходимо реализовать graceful shutdown и автоматическое переподключение.

Graceful shutdown на стороне сервера

При завершении работы сервер должен корректно закрыть все WebSocket соединения, отправив close frame:

void shutdown() {
    std::lock_guard<std::mutex> lock(sessions_mutex_);
    for (auto& session : sessions_) {
        session->close(); // Отправка close frame
    }
    sessions_.clear();
    acceptor_.close();
}

Клиент с автоматическим переподключением (reconnect)

Клиентская часть должна уметь восстанавливать соединение с экспоненциальной задержкой:

class WebSocketClient : public std::enable_shared_from_this<WebSocketClient> {
    websocket::stream<beast::tcp_stream> ws_;
    net::io_context& ioc_;
    std::string host_;
    std::string port_;
    int retry_delay_ = 1; // секунды

public:
    void connect() {
        tcp::resolver resolver(ioc_);
        auto results = resolver.resolve(host_, port_);
        net::async_connect(ws_.next_layer(), results,
            [self = shared_from_this()](beast::error_code ec, auto) {
                if (ec) {
                    // Экспоненциальная задержка
                    self->retry_delay_ = std::min(self->retry_delay_ * 2, 60);
                    std::this_thread::sleep_for(
                        std::chrono::seconds(self->retry_delay_));
                    self->connect();
                    return;
                }
                self->retry_delay_ = 1;
                self->do_handshake();
            });
    }

private:
    void do_handshake() {
        ws_.async_handshake(host_, "/",
            [self = shared_from_this()](beast::error_code ec) {
                if (ec) {
                    self->connect();
                    return;
                }
                self->do_read();
            });
    }
};