¿Servidor multiproceso simple en C++?

Question

Quiero escribir una aplicación de servidor simple que tome los comandos de una aplicación cliente y ejecute esos comandos en hilos separados.

Estaba mirando el server class in dlib. ¿Alguien tiene experiencia en usar esto? ¿Cómo se compara con el uso de Asio de Boost?

• Example of server in dlib
• Examples of client/server in Boost Asio

Answer 1

Boost Asio lo hará con bastante facilidad. Eche un vistazo a the examples in the Highscore tutorial, que muestra cómo usar Boost para entradas/salidas asíncronas con multihilo.

#include <boost/asio.hpp> 
#include <boost/thread.hpp> 
#include <iostream> 

void handler1(const boost::system::error_code &ec) 
{ 
    std::cout << "5 s." << std::endl; 
} 

void handler2(const boost::system::error_code &ec) 
{ 
    std::cout << "5 s." << std::endl; 
} 

boost::asio::io_service io_service; 

void run() 
{ 
    io_service.run(); 
} 

int main() 
{ 
    boost::asio::deadline_timer timer1(io_service, boost::posix_time::seconds(5)); 
    timer1.async_wait(handler1); 
    boost::asio::deadline_timer timer2(io_service, boost::posix_time::seconds(5)); 
    timer2.async_wait(handler2); 
    boost::thread thread1(run); 
    boost::thread thread2(run); 
    thread1.join(); 
    thread2.join(); 
} 

Answer 2

me gustaría probar y no utilizar hilos al principio. Comenzaría con libevent. Encontrará que el modelo libevent es extremadamente simple y scales out way better than spawning a thread per request model. Y si libevent no puede manejar su caso de uso, ¡siempre hay Erlang!

Answer 3

La E/S asincrónica es mejor en bastantes maneras que el modelo de hilo por cliente. El rendimiento óptimo es en realidad logrado por hilo por núcleo, con cada hilo realizando E/S asíncronas.

Tenga en cuenta que su concepto de "servidor multiproceso", aunque no es exactamente incorrecto, es bastante diferente de lo que todos los demás usan en esa frase. En general, significa un hilo por conexión y no la respuesta a una conexión paralelizada a través de hilos.

El ejemplo que está solicitando es simplemente una combinación de servidor síncrono de subprocesamiento único + cálculo en paralelo.