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

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

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

Начать курс

WebSocket на C++: Создание высокопроизводительных real-time приложений

В современном мире веб-разработки real-time взаимодействие стало стандартом де-факто для финансовых платформ, онлайн-игр, систем мониторинга и чатов. Если вам нужна максимальная производительность и минимальная задержка, C++ остается безальтернативным выбором. В этой статье мы рассмотрим продвинутые техники работы с WebSocket на C++, выходящие за рамки простого 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 handshake
        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("Добро пожаловать в real-time мир!")),
                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();
}

Важно: При такой архитектуре все обработчики внутри сессии должны быть потокобезопасными. Используйте std::mutex или стратегию "один поток на соединение" (но это дороже по памяти).

3. Обработка сообщений и бродкастинг

Real-time приложение редко работает с одним клиентом. Часто требуется разослать сообщение всем (broadcast) или определенной группе (rooms). Реализуем простой менеджер комнат.

class RoomManager {
    std::unordered_map<std::string, std::vector<std::weak_ptr<WebSocketSession>>> rooms_;
    std::mutex mtx_;
public:
    void join(const std::string& room, std::shared_ptr<WebSocketSession> session) {
        std::lock_guard<std::mutex> lock(mtx_);
        rooms_[room].push_back(session);
    }

    void broadcast(const std::string& room, const std::string& message) {
        std::lock_guard<std::mutex> lock(mtx_);
        auto& sessions = rooms_[room];
        sessions.erase(
            std::remove_if(sessions.begin(), sessions.end(),
                [&](auto& wp) { return wp.expired(); }),
            sessions.end());

        for (auto& wp : sessions) {
            if (auto sp = wp.lock()) {
                sp->send(message); // Асинхронная отправка
            }
        }
    }
};

Обратите внимание на использование weak_ptr и очистку "мертвых" сессий — это предотвращает утечки памяти.

Теперь в методе on_read сессии мы можем парсить JSON и вызывать broadcast:

void on_read(beast::error_code ec, std::size_t bytes_transferred) {
    boost::ignore_unused(bytes_transferred);
    if(ec) return;

    std::string msg = beast::buffers_to_string(buffer_.data());
    buffer_.consume(buffer_.size());

    // Парсим JSON (например, с помощью nlohmann/json)
    auto json = nlohmann::json::parse(msg);
    if (json["type"] == "join") {
        room_manager_->join(json["room"], shared_from_this());
    } else if (json["type"] == "message") {
        room_manager_->broadcast(json["room"], json["data"]);
    }
    do_read(); // Снова ждем сообщение
}