• The work a server needs to do in order to meet the client's request might be time consuming—so time consuming that a sequential implementation might interfere with the server's ability to accept future requests.
• One solution: as soon as accept returns a socket descriptor, spawn a child thread to get any intense, time consuming computation off of the main thread. The child thread can make use of a second processor or a second core, and the main thread can quickly move on to its next accept call.

• Here's the same time server example, save for its decision to use threading to compute and publish the time back to the client.

int main(int argc, char *argv[]) {
  if (argc > 1) {
    cerr << "Usage: " << argv[0] << endl;
    return kWrongArgumentCount;
  }

  int serverSocket = createServerSocket(kDefaultPort);
  if (serverSocket == kServerSocketFailure) {
    cerr << "Error: Could not start time server to listen to port " << kDefaultPort << "." << endl;
    cerr << "Aborting... " << endl;
    return kServerStartFailure;
  }

  cout << "Server listening on port " << kDefaultPort << "." << endl;  
  ThreadPool pool(4);
  while (true) {
    int clientSocket = accept(serverSocket, NULL, NULL);
    pool.schedule([clientSocket] { publishTime(clientSocket); });
  }
  return 0;
}

• Note the use of a ThreadPool to get the server-side computation off of the the main thread. This way, the main thread can rotate around and more immediately advance on to other accept requests.

• The implementation of publishTime must change if it's to be thread safe. The change is simple but important: we need to call a reentrant, thread safe version of gmtime called gmtime_r.
  • gmtime returns a pointer to a single, statically allocated record of time information that's used by all calls to it. If two threads make competing calls to it, then both threads race to pull time information from the shared, statically allocated record.
  • One solution is to use a mutex to ensure that a thread can call gmtime without competition and subsequently copy the data out of the static record into a local character buffer.
  • Another solution—one that doesn't require locking and one I think is better—makes use of a second version of the same function called gmtime_r. The second, reentrant version just requires that space for a dedicated return value be passed in.

static void publishTime(int clientSocket) {
  time_t rawtime;
  time(&rawtime);
  struct tm tm;
  gmtime_r(&rawtime, &tm);
  char timeString[128]; // more than big enough
  /* size_t len = */ strftime(timeString, sizeof(timeString), "%c", &tm);
  sockbuf sb(clientSocket); // destructor closes socket
  iosockstream ss(&sb);
  ss << timeString << endl;
}