Setting up a multi-client/server TCP connection in Java

You appear to have tangled Thread and objects. I would

a) make sure you are not extending Thread anywhere or calling your objects XxxxThread. Using an ExecutorService to manage your threads is a good idea.

b) have a simple model for responding to client commands, e.g. each client thread reads a task and then performs a task.

c) Have a wrapper for each connections, e.g. with a sendMessage method.

Since you already know about sockets and threads, I send you the idea pseudo code (case need a specific part of code just let me know)

One thing you did not mention is how to keep track of clients, by its IP o by any other method like an ID? Can any given device open more than one connection with different client ID? Or you'll only accept one connection per device? In any case, if a client is already in the list, what do you suposse to do? Will you communicate the created thread the new socket? Will you destroy that thread and create a new one? Or maybe you'll ignore this new request?

This is my idea (taken from a working application):

Server prepares the server socket and wait in the accept state.

Once a client connects, the server start a thread to attend the client passing the socket it just created with the accept command. When the thread which attends the client starts, the very first message it receives from the client should be a password o special signature to let the client gets in (this is optional).

Server code:

Prepares the server socket which listen in a well known port
Clear client list;

While (!Terminated)
{
      // if you want to impose a limit for connections, check it here:
      if (Is the list of connected client full?)
      {
           Sleep(reasonable time in seconds or miliseconds);
           continue;
       }
       ClientSocket = ServerSocket.Accept();
       if the client's IP is already in the list
       {
           depends on what you want to do.
       }
       else
       {
            Add client's IP to the list
            Start (create) new client Tread(ClientSocket);
       }
}
// when server finish
If (client list is not empty?)
{
   Kill all threads
   or
   Wait until all threads are done
   or
   Wait an amount of time and then kill those remaining.
}

thread client code:

// This is optional, just to make sure a valid client is connected
Read packet from ClientSocket
if (!Is_the_passport_packet)
{
   close socket;
   return;
}

// if passport is not required, start here
Try
{
   While (!Terminated)
   {
      if (read packet from client);
      {
         switch (packet.Command)
         {
 // In your question you said you want the Server thread to process the request
 // I guess you have your requirements to do so,
 // anyway, you must use a mutex o some other synchronization method.
             case TASK_1:
                [sync] process TASK_1(packet, ClientSocket);
                break;
             case TASK_2:
                [sync] process TASK_2(packet, ClientSocket);
                break;
             etc ….

             case WORK_DONE:
                Close Socket;
                return;

             default:
                Log(received an unknown command: packet.command);
                break;

         }
      }
      else if (Client has quit (closed/broken socket))
      {
         // as you may know, a socket is consider shutdown when you received a 0 length data
         // and a broken connection when received -1 in either case all you have to do is
         Close Socket;
         return;
      }
  }
}
catch (Exception e)
{
    Log(received an exception: e.message);
}
finally
{
   Remove this client from the client's list
}