Multithreaded Servers

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.

What is a Multithreaded Server?

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.

Why Do We Need Multithreading?

A normal (single-threaded) server:

• Handles one client at a time
• Other clients must wait in queue
• Leads to slow response time and poor performance

Problem: Not scalable for multiple users

Solution: Multithreading

• Each client is handled in a separate thread
• Multiple clients can communicate at the same time
• Improves performance and responsiveness

👉 Instead of one worker handling all tasks, multiple workers handle clients in parallel.

Handling Multiple Clients

Basic Idea

When a client connects:

1. Server accepts connection
2. A new thread is created for that client
3. That thread handles client communication independently
4. Server immediately goes back to listening for new clients

👉 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.

Thread-per-Client Model

This is the most basic multithreading approach used in server design.

👉 Each client is handled by one separate thread.

How It Works

• Server listens for incoming connections using ServerSocket
• When a client connects using accept()
• A new thread is created for that client
• That thread handles all input/output communication
• Server continues listening for other clients

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 5000
• accept() → Waits for client connection
• while(true) → Keeps server running for multiple clients
• ClientHandler extends Thread → Creates a new thread for each client
• run() → Contains logic for handling client communication
• Each client runs independently without blocking others

Using ExecutorService

Instead of manually creating threads, Java provides a better and more efficient way:

👉 ExecutorService (Thread Pool)

Why Thread Pool?

• Reuses existing threads instead of creating new ones every time
• Prevents overhead of excessive thread creation
• Improves application performance
• Provides better resource management and control

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 efficiently
• newFixedThreadPool(5) → Allows maximum 5 threads to run at the same time
• execute() → Assigns each client request to an available thread

Difference Between Thread and ExecutorService

Performance Considerations

Multithreaded servers improve performance, but they still have some important limitations that must be considered while designing real-world systems.

1. Too Many Threads

Problem:

• Each thread consumes memory and system resources
• Large number of clients can overload the system

Solution:

• Use thread pool instead of creating a new thread every time

2. Context Switching Overhead

• CPU continuously switches between multiple threads
• This switching takes time and reduces overall efficiency
• More threads = more overhead

3. Blocking I/O

• Traditional socket communication is blocking in nature
• A thread waits while data is being read or written
• This keeps resources occupied unnecessarily

4. Scalability Limit

• Thread-per-client model works only for small to medium applications
• It is not suitable for thousands of concurrent users
• Modern systems use advanced models (like async or NIO) for better scalability

Best Practices

• Always use ExecutorService (thread pool) instead of creating new threads
• Limit the number of threads based on system capacity
• Always close sockets properly after use
• Handle exceptions inside each thread to avoid server crash
• Use logging for debugging and monitoring
• Avoid long blocking operations inside threads

Real-World Use Cases

Multithreaded servers are widely used in modern applications where multiple users connect at the same time:

• Chat applications (WhatsApp-style messaging systems)
• Online gaming servers (real-time multiplayer interaction)
• Banking systems (secure and concurrent transactions)
• REST APIs (Spring Boot backend services handling multiple requests)
• File transfer systems (simultaneous upload/download by users)

Common Mistakes to Avoid

• Creating unlimited threads (leads to memory and CPU overload)
• Not closing sockets properly (causes resource leaks)
• No exception handling in server or client code
• Blocking the main server thread instead of delegating work
• Ignoring thread safety when multiple threads access shared data

Conclusion

Multithreaded servers are essential for building scalable Java applications.

• Handle multiple clients simultaneously
• Improve performance and responsiveness
• Can be implemented using thread-per-client or thread pool models
• 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.