2.5. Handling Multiple Clients

For handling multiple clients in a TCP server, multithreading is commonly used.

In server applications, particularly those that communicate over the TCP protocol, it's essential for the server to manage multiple clients simultaneously. Multithreading is a programming concept that enables a server to handle multiple connections by using different threads for each client session. This way, while one client is sending data or waiting for a response, the server can still interact with other clients without delay.

Think of a restaurant with one waiter (the server) serving multiple tables (clients). If a waiter focuses solely on one table at a time, it could lead to long wait times for the other tables. However, if the waiter can take orders (start a thread), deliver food (handle another thread), and check up on diners (yet another thread) all at the same time, the service becomes much more efficient.

import java.io.*;
import java.net.*;
public class MultiClientServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(7000);
System.out.println("Server started...");
while (true) {
Socket socket = serverSocket.accept();
new ClientHandler(socket).start();
}
}
}
class ClientHandler extends Thread {
private Socket socket;
public ClientHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
String clientMsg = reader.readLine();
System.out.println("Client says: " + clientMsg);
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
writer.println("Hello from server");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

This code snippet demonstrates a simple multi-threaded server in Java. When the server starts, it listens for incoming client connections on port 7000. Inside an infinite loop, it accepts a connection (which blocks until a client tries to connect). After accepting a connection, it creates a new thread instance of the ClientHandler class, passing the accepted socket. Each ClientHandler is responsible for interacting with a specific client. For each client, it reads a message, prints it, sends a response back, and finally closes the connection.

Imagine a call center where each operator (thread) handles a different call (client). When a new call comes in, it gets assigned to an available operator who then talks to the caller without interrupting the calls handled by the other operators. Here each operator is like a ClientHandler, managing an individual call independently.

class ClientHandler extends Thread {
private Socket socket;
public ClientHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
String clientMsg = reader.readLine();
System.out.println("Client says: " + clientMsg);
PrintWriter writer = new PrintWriter(socket.getOutputStream(), true);
writer.println("Hello from server");
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

The ClientHandler class extends the Thread class and represents the worker that handles communication with the client. It has a constructor that takes a Socket object, which represents the connection to the client. The run() method, which is executed when the thread is started, reads a message from the client, outputs it to the server console, sends a reply back to the client, and closes the socket to end the communication. This encapsulation allows each client’s interactions to occur independently.

Consider a receptionist who receives various clients (calls) one by one. Each client’s query is handled in a discrete manner without affecting the others. Each receptionist (ClientHandler) acts independently, helping clients (handling requests) while maintaining overall service quality. Once their task is complete, they can move on to the next client.

--