Long polling vs WebSocket en C++: qué elegir para tiempo real

Long polling vs WebSocket en C++: La batalla por el tiempo real

Imagine: está escribiendo un chat en C++, un terminal bursátil o un sistema de monitoreo de servidores. El cliente debe recibir datos al instante. Las solicitudes HTTP de "pregunta-respuesta" no son adecuadas: son demasiado lentas y derrochadoras. Hay dos opciones: Long polling (la vieja escuela) y WebSocket (el estándar moderno). ¿Qué elegir para un proyecto en C++? Vamos a analizarlo con ejemplos reales.

Cómo funciona Long polling en C++ (y por qué sigue vivo)

Long polling es una emulación de tiempo real sobre HTTP normal. El cliente envía una solicitud, el servidor no responde de inmediato, sino que "cuelga" hasta que aparecen nuevos datos o se agota el tiempo de espera. Tan pronto como aparecen los datos, el servidor envía la respuesta y el cliente envía inmediatamente una nueva solicitud. Se crea la ilusión de un flujo continuo.

En C++, este enfoque a menudo se implementa mediante libcurl en el cliente y cualquier servidor HTTP (por ejemplo, cpp-httplib o Boost.Beast) en el servidor. Así es como se ve la parte clásica del servidor con Boost.Beast:

#include <boost/beast/core.hpp>\n#include <boost/beast/http.hpp>\n#include <boost/beast/version.hpp>\n#include <boost/asio.hpp>\n#include <queue>\n#include <mutex>\n#include <condition_variable>\n\nnamespace beast = boost::beast;\nnamespace http = beast::http;\nnamespace net = boost::asio;\n\nclass LongPollHandler {\n    std::queue<std::string> messages_;\n    std::mutex mtx_;\n    std::condition_variable cv_;\npublic:\n    // Método seguro para hilos para agregar un mensaje\n    void push(const std::string& msg) {\n        std::lock_guard<std::mutex> lock(mtx_);\n        messages_.push(msg);\n        cv_.notify_one();\n    }\n\n    // Manejador de solicitud Long Polling\n    void handle(http::request<http::string_body>& req,\n                http::response<http::string_body>& res) {\n        std::unique_lock<std::mutex> lock(mtx_);\n        // Esperamos un nuevo mensaje o un tiempo de espera de 30 segundos\n        if (cv_.wait_for(lock, std::chrono::seconds(30),\n                         [this](){ return !messages_.empty(); })) {\n            std::string msg = messages_.front();\n            messages_.pop();\n            res.result(http::status::ok);\n            res.body() = msg;\n        } else {\n            // Tiempo de espera agotado: devolvemos una respuesta vacía\n            res.result(http::status::no_content);\n            res.body() = "";\n        }\n        res.prepare_payload();\n    }\n};

El cliente con libcurl se verá así:

#include <curl/curl.h>\n#include <string>\n#include <iostream>\n\nsize_t write_callback(void* contents, size_t size, size_t nmemb, void* userp) {\n    ((std::string*)userp)->append((char*)contents, size * nmemb);\n    return size * nmemb;\n}\n\nvoid long_poll_loop(CURL* curl, const std::string& url) {\n    std::string response;\n    while (true) {\n        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());\n        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);\n        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);\n        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 35L); // un poco más que el tiempo de espera del servidor\n\n        CURLcode res = curl_easy_perform(curl);\n        if (res == CURLE_OK && !response.empty()) {\n            std::cout << "Recibido: " << response << std::endl;\n            response.clear();\n            // enviamos inmediatamente una nueva solicitud\n            continue;\n        }\n        // En caso de error, esperamos 5 segundos y repetimos\n        std::this_thread::sleep_for(std::chrono::seconds(5));\n    }\n}

Ventajas de Long polling en C++: Simplicidad, compatibilidad con todos los proxies y firewalls, no requiere bibliotecas especiales. Desventajas: Gran cantidad de encabezados HTTP, retrasos en el establecimiento de la conexión (TCP ha