Author
A single-client server is useful for learning, but real-world applications like chat apps, banking systems, and APIs must handle many clients at the same time. That’s where multithreaded servers come in.
This guide explains how Java handles multiple clients efficiently using threads and modern concurrency tools.
A multithreaded server is a server that can handle multiple client connections simultaneously using separate threads.
In simple words: Each client gets its own “worker thread” so the server does not block for other clients.
? This improves performance and allows concurrent communication with multiple clients.
A normal (single-threaded) server:
Problem: Not scalable for multiple users
Solution: Multithreading
? Instead of one worker handling all tasks, multiple workers handle clients in parallel.
Basic Idea
When a client connects:
? This ensures the server does not stop or wait while handling one client.
Flow Diagram
Client 1 → Thread 1
Client 2 → Thread 2
Client 3 → Thread 3
↓
Server
Each client gets its own separate thread, so multiple clients can interact with the server at the same time without blocking each other.
This is the most basic multithreading approach used in server design.
? Each client is handled by one separate thread.
ServerSocketaccept()Example: Thread-per-Client Server
import java.net.*;
import java.io.*;
public class MultiClientServer {
public static void main(String[] args) throws Exception {
ServerSocket server = new ServerSocket(5000);
System.out.println("Server started...");
while (true) {
Socket socket = server.accept();
System.out.println("Client connected");
// Create new thread for each client
new ClientHandler(socket).start();
}
}
}
class ClientHandler extends Thread {
Socket socket;
public ClientHandler(Socket socket) {
this.socket = socket;
}
public void run() {
try {
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream())
);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
String message = in.readLine();
System.out.println("Client says: " + message);
out.println("Hello Client, message received");
socket.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
Explanation
ServerSocket(5000) → Starts server on port 5000accept() → Waits for client connectionwhile(true) → Keeps server running for multiple clientsClientHandler extends Thread → Creates a new thread for each clientrun() → Contains logic for handling client communicationInstead of manually creating threads, Java provides a better and more efficient way:
? ExecutorService (Thread Pool)
Example: Multithreaded Server using ExecutorService
import java.net.*;
import java.io.*;
import java.util.concurrent.*;
public class ThreadPoolServer {
public static void main(String[] args) throws Exception {
ServerSocket server = new ServerSocket(5000);
System.out.println("Server started...");
ExecutorService pool = Executors.newFixedThreadPool(5);
while (true) {
Socket socket = server.accept();
pool.execute(new ClientTask(socket));
}
}
}
class ClientTask implements Runnable {
Socket socket;
public ClientTask(Socket socket) {
this.socket = socket;
}
public void run() {
try {
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream())
);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
String msg = in.readLine();
System.out.println("Client: " + msg);
out.println("Response from Thread Pool Server");
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Key Points
ExecutorService manages a pool of threads efficientlynewFixedThreadPool(5) → Allows maximum 5 threads to run at the same timeexecute() → Assigns each client request to an available thread| Feature | Thread-per-client | ExecutorService |
|---|---|---|
| Performance | Low (due to frequent thread creation) | High (thread reuse via pool) |
| Resource usage | High (each client creates new thread) | Optimized (fixed thread pool) |
| Scalability | Poor (overload under many clients) | Good (handles many clients efficiently) |
| Management | Manual (developer handles threads) | Automatic (framework manages threads) |
Multithreaded servers improve performance, but they still have some important limitations that must be considered while designing real-world systems.
Problem:
Solution:
ExecutorService (thread pool) instead of creating new threadsMultithreaded servers are widely used in modern applications where multiple users connect at the same time:
Multithreaded servers are essential for building scalable Java applications.
ExecutorService is the recommended modern approach for better efficiency and resource management? Multithreading allows a server to serve many clients at the same time without slowing down.