Multiple client and single server handling - c++

Question

Will this approach work?
I am gonna simply present my code in simplified form for easier readability.
I am trying to implement a multiple client/one TCP server.
My listener will loop like this(as a thread) which handles connections
void WaitAndAcceptConnection(){
if(socket_TEMP = accept(sock_LISTEN, (SOCKADDR*)&ADDRESS, &AddressSize))
{
socketsManager.push_back(socket_TEMP);
currCount++;
std::cout<<"\n A connection was found!"<<std::endl;
send(socketsManager[currCount], "Welcome! you have connected to Athena Server", 46,NULL);
// cond.notify_one(); //notify the waiting thread
}
}
wherein i have..
std::vector<SOCKET> socketsManager; //handles socket
int currCount=-1; //keep track on the number of connections
If a client connected then currCount will be increased by one, in our case it's gonna be currCount = 0 and then socketsManager[0] will store the accept's return. If another one connected then currCount = 1 then socketsManager[1] will be its handler.
For sending and receiving data.
I am gonna make a for loop that will continue on iterating to check if there is a recv'd data(-1 or 0) for every sockets that is being handled by my program.
void WaitAndAcceptCommands(){
for(int i = 0; i<= currCount;i++){
int result = recv(socketsManager[i],&command,1,0);
if(result ==-1){
}
else if(result == 0){
}
else{
//process commands
}
}
}
Main will be something like this
Athena ath2; //instance of the server
std::cout<<"\n >Waiting for incoming connections..."<<std::endl;
//listener thread, just keep on LOOPING
std::thread connectionThread([&](){
while(1){
ath2.WaitAndAcceptConnection();
}
});
//handles all the inputs, JUST KEEP ON LOOPING
std::thread commandsThread([&](){
while(1){
ath2.WaitAndAcceptCommands();
}
});
connectionThread.join(); //stop
commandsThread.join(); //stop
I would gladly show the rest of my code but they are in a complete mess right now. I only wanted to present the idea if this will work and then i will continue on it, if not then i will reconsider another method. I plan on handling my connections through timeouts if i will ever have to drop a socket from my std::vector<SOCKET> socketsManager; by using remove. Is this a good method? if not then what are the issues?

Answer 1

I see a couple of problems with what you're doing:
You're pushing to socketsManager vector indefinitely. It won't be long before you run out of memory / file descriptors.
Protect access to socketsManager with some lock, else you can have race condition.
One way to do this is to use event loop:
Have one or more threads for doing I/O.
Each I/O thread operates on a list of open sockets.
It uses select() or poll() to figure out which socket amongst the set it is operating on has data available. Invokes the necessary callbacks with the data that was read.
Processing the data is handled by worker threads. The callback invoked one of the worker thread which processes the data.
References:
http://instagram-engineering.tumblr.com/post/121930298932/c-futures-at-instagram (see non-blocking IO section)