18.6. Multi-threaded Server Programming

To handle multiple clients simultaneously:

class ClientHandler extends Thread {
    private Socket clientSocket;
    public ClientHandler(Socket socket) {
        this.clientSocket = socket;
    }
    public void run() {
        try {
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                out.println("Echo from server: " + inputLine);
            }
            in.close();
            out.close();
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

The ClientHandler class is a custom class that extends the Thread class in Java, allowing it to run separately from the main server thread. When a client connects to the server, a new instance of ClientHandler is created with the client's socket. Inside the run method, the server reads messages from the connected client until the client stops sending messages (inputLine = in.readLine() returns null). For each message received, the server responds back with an echo of the same message. This loop allows the server to handle multiple clients concurrently, with each client handled in its own thread.

Imagine a restaurant where each waiter (thread) has several tables (clients) to serve. When a customer at a table makes an order (sends a message), the waiter takes it to the kitchen (the server), gets the food (processes the message), and brings it back to the customer. Meanwhile, the same waiter can take new orders from other tables, allowing multiple customers to be served at once.

And in the main server:

ServerSocket serverSocket = new ServerSocket(5000);
while (true) {
    Socket socket = serverSocket.accept();
    new ClientHandler(socket).start();
}

This part of the code initializes a ServerSocket on port 5000, making it listen for incoming client connections. The server runs an infinite loop (while (true)), meaning it continuously checks for new connections. Each time a client connects (using serverSocket.accept()), it creates a new ClientHandler object for that client and starts it in a new thread using start(). This allows the server to keep accepting new connections while also handling multiple already-connected clients without blocking.

Think of a front desk at a hotel where the receptionist (server) is constantly checking in new guests (clients). Each time a new guest arrives, the receptionist hands them off to one of the waiting bellhops (client handlers) to assist them while continuing to check in more guests. This process ensures that all guests receive timely service without having to wait.

--