Queue socket connection in C

Due to listena backlog of pending features, ie. It will keep all connections in a queue and when acceptcalled, actually wait for the first element in the queue to be accepted, the solution for this is as follows.

In an infinite loop, connections are only accepted as long as the counter is less than a certain number (the maximum number of clients to serve simultaneously). Declare a mutexcounter that protects the counter, which is incremented each time a connection is accepted. Declare a condition variable to b to signal when the thread has completed its task. Using that condition variable and a mutex, wait if counter is greater than X. After the thread serving the client completes its task, it decrements counter and signals the condition. So the infinite loop will loop again and accept clients already reserved.

A possible implementation could be:

// global variable 
pthread_mutex_t lock;
pthread_cond_t cv;
int number_of_connected_client = 0;

// a function executed by a thread to handle each user
void *client_thread(void *arg) {

  /* some code */

  // thread is about to finish and return
  // client disconnected --> decrement number of connected clients 
  // signal that a client disconnected
  pthread_mutex_lock(&lock);
  number_of_connected_client-- ;
  pthread_cond_signal(&cv);
  pthread_mutex_unlock(&lock);
  return 0;
}

// infinte loop for accepting connections
while (1) {

  // serve 2 users at a time, queue the rest of the clients in the listen's queue 
  if( number_of_connected_client >= 2 ) {
    pthread_mutex_lock(&lock);      
    pthread_cond_wait(&cv, &lock);
    pthread_mutex_unlock(&lock);
  }

  connfd = accept(listenfd, (struct sockaddr *) NULL, NULL );

  // create a thread and serve the client 
  if( pthread_create( &thread_id , NULL , client_thread, (void*)connfd) <0)
    {
     // error in creating thread
     // do something 
    }

  // client is served --> increment number of connected clients 
  else {
    pthread_mutex_lock(&lock);
    number_of_connected_client ++;
    pthread_mutex_unlock(&lock);
  }

}

It's just a simple workaround to enable things to be privately tested or hardware tested, etc. The correct way to handle this is to pool threads and assign the worker threads the task provided by the Inspired annotation.