Gran cantidad de conexiones simultáneas en el ahorro

Question

Estoy intentando escribir un servidor simple con Thrift. Al principio parecía prometedor, pero me encontré con un problema con una cantidad de clientes conectados al mismo tiempo. Estoy usando TThreadPoolServer, que permite a 4 clientes conectarse y luego bloquea a otros clientes hasta que elimine uno de los conectados. ¿Qué puedo hacer para permitir que se conecten más (posiblemente varios cientos) clientes al mismo tiempo, sin aumentar la cantidad de subprocesos? Supuse que los subprocesos de trabajo permiten realizar una solicitud de cliente a la vez, pero parece que un subproceso maneja una conexión hasta que se cierra. Me gustaría evitar una situación en la que mis clientes tengan que volver a abrir un socket para realizar una acción.

Answer 1

Tomando otro enfoque, si usa C++ para construir su servidor, puede usar TNonblockingServer en lugar de TThreadPoolServer, lo que le permitirá aceptar muchas conexiones a la vez, independientemente de cuántos hilos estén activos, etc ...

Habiendo dicho eso, no necesariamente podrá hacer el trabajo más rápido (los manipuladores todavía se ejecutan en un grupo de subprocesos), pero más clientes podrán conectarse con usted de inmediato.

Aquí es lo que el código es el siguiente para el servidor NB:

shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory()); 
shared_ptr<MyHandler> handler(new MyHandler()); 
shared_ptr<TProcessor> processor(new MyProcessor(handler)); 
TNonblockingServer server(processor, protocolFactory, port); 

Answer 2

Su prescripción de cuatro hilos en la piscina está integrado en el constructor por defecto de la SimpleThreadManager:

class SimpleThreadManager : public ThreadManager::Impl { 

public: 
    SimpleThreadManager(size_t workerCount=4, size_t pendingTaskCountMax=0) : 
    workerCount_(workerCount), 
    pendingTaskCountMax_(pendingTaskCountMax), 
    firstTime_(true) { 
    } 
... 
}; 

Este objeto ThreadManager se pasa a la coonstructor ThreadPoolServer, por lo que pasar un número mayor al constructor de este objeto para aumentar el tamaño de su grupo de subprocesos