Building TCP Servers: ServerSocket, Multi-Threading, and NIO Selectors
Building TCP Servers: ServerSocket, Multi-Threading, and NIO Selectors
अगर आप Java Networking सीख रहे हैं, तो “TCP Server” बनाना एक बहुत ही ज़रूरी concept है। इस topic में हम step-by-step समझेंगे कि कैसे ServerSocket का use करके TCP Server बनाया जाता है, कैसे multi-threading के ज़रिए multiple clients को handle किया जाता है, और कैसे NIO Selectors performance को boost करते हैं। यह topic college exams और practical lab दोनों के लिए बहुत important है।
What is TCP Server?
TCP (Transmission Control Protocol) एक reliable communication protocol है जो data को सुरक्षित और sequence में भेजने के लिए use किया जाता है। जब हम TCP Server बनाते हैं, तो हमारा server client के साथ connection establish करता है और continuous data exchange करता है।
TCP Server हमेशा “listening mode” में रहता है, यानी वो किसी port पर incoming connections का इंतज़ार करता है। जब कोई client connect करता है, तब server उसे accept करता है और data communication शुरू करता है।
Key Features of TCP Server
- Reliable connection – data loss नहीं होता।
- Ordered delivery – messages उसी क्रम में पहुंचते हैं।
- Full-duplex communication – दोनों तरफ से data भेजा जा सकता है।
- Persistent connection – जब तक client disconnect नहीं करता, link बना रहता है।
Introduction to ServerSocket in Java
Java में TCP Server बनाने के लिए ServerSocket class का use किया जाता है। यह class java.net package में होती है और TCP connections को handle करने का base mechanism देती है।
Basic Functions of ServerSocket
ServerSocket(int port)– किसी specific port पर server शुरू करता है।accept()– client से connection request accept करता है।close()– server को बंद करता है।
Example: Simple TCP Server Using ServerSocket
नीचे एक simple TCP server का code दिया गया है जो client से message receive करता है और उसे वापस भेजता है (echo server की तरह):
import java.io.*;
import java.net.*;
public class SimpleTCPServer {
public static void main(String[] args) {
try (ServerSocket server = new ServerSocket(5000)) {
System.out.println("Server started. Waiting for client...");
Socket socket = server.accept();
System.out.println("Client connected.");
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter output = new PrintWriter(socket.getOutputStream(), true);
String message = input.readLine();
System.out.println("Received: " + message);
output.println("Echo: " + message);
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
ऊपर दिए गए code में server 5000 port पर listen करता है और जब कोई client connect करता है, तो उससे message लेकर वही वापस भेज देता है।
Building Multi-Threaded TCP Server
अगर आपके server को multiple clients को एक साथ handle करना है, तो आपको multi-threading का use करना पड़ेगा। Multi-threaded server में हर client के लिए एक नया thread बनाया जाता है, जिससे हर connection parallel process हो सके।
Why Multi-Threading is Important?
- Multiple clients को simultaneously handle किया जा सकता है।
- Server response fast रहता है।
- Blocking operations का impact कम होता है।
Example: Multi-Threaded TCP Server
import java.io.*;
import java.net.*;
public class MultiThreadedServer {
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(6000)) {
System.out.println("Server is running on port 6000...");
while (true) {
Socket client = serverSocket.accept();
System.out.println("New client connected.");
new ClientHandler(client).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ClientHandler extends Thread {
private 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;
while ((message = in.readLine()) != null) {
System.out.println("Received: " + message);
out.println("Server: " + message);
}
} catch (IOException e) {
System.out.println("Client disconnected.");
}
}
}
यह server हर नए client के लिए एक नया thread create करता है। इससे कई users एक साथ server से connect हो सकते हैं और independent communication कर सकते हैं।
High-Performance TCP Server with NIO Selectors
Java NIO (New Input/Output) package high-performance networking applications के लिए use होता है। इसका सबसे बड़ा फायदा है — “non-blocking I/O”, जिससे server एक साथ कई connections को manage कर सकता है बिना हर client के लिए नया thread बनाए।
Key Concepts in NIO Server
- Channel: यह stream की तरह काम करता है लेकिन asynchronous data read/write support करता है।
- Buffer: Data store करने के लिए memory region।
- Selector: Multiple channels को monitor करने के लिए object।
How NIO Server Works
Selector continuously check करता है कि कौन-सा channel read/write operation के लिए ready है। इससे single thread multiple clients handle कर सकता है।
Example: NIO TCP Server
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
public class NIOServer {
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(7000));
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("NIO Server started on port 7000");
while (true) {
selector.select();
Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
while (keys.hasNext()) {
SelectionKey key = keys.next();
keys.remove();
if (key.isAcceptable()) {
SocketChannel client = serverChannel.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
System.out.println("New client connected.");
} else if (key.isReadable()) {
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(256);
int bytesRead = client.read(buffer);
if (bytesRead == -1) {
client.close();
} else {
String message = new String(buffer.array()).trim();
System.out.println("Received: " + message);
buffer.flip();
client.write(ByteBuffer.wrap(("Echo: " + message).getBytes()));
}
}
}
}
}
}
ऊपर के example में server एक single thread में multiple clients को manage करता है। इस approach से memory और CPU दोनों efficiently use होते हैं।
Comparison Table: ServerSocket vs Multi-Threading vs NIO
| Feature | ServerSocket | Multi-Threaded Server | NIO Selector Server |
|---|---|---|---|
| Performance | Low (Single client only) | Medium (Multiple threads) | High (Non-blocking I/O) |
| Resource Usage | Minimal | More (per thread memory) | Optimized |
| Scalability | Low | Moderate | Excellent |
| Complexity | Easy | Medium | High |
| Use Case | Single client testing | Small multi-client apps | Large-scale servers |
Important Points for College Exams
- ServerSocket class हमेशा TCP connection के लिए use होती है।
- accept() method blocking होती है – जब तक client connect न करे, wait करती है।
- Multi-threaded servers multiple clients को parallel handle करते हैं।
- NIO Selector non-blocking communication enable करता है।
- Practical exam में simple ServerSocket example बहुत बार पूछा जाता है।
Quick Notes for Revision
- TCP Server reliable, ordered, and connection-oriented communication provide करता है।
- Java में
ServerSocketTCP connection handle करने के लिए responsible है। - Multi-threading performance improve करती है लेकिन resource usage बढ़ाती है।
- NIO Selector single-threaded high-performance server बनाने में मदद करता है।
- Exam में code-based question आने पर basic echo server याद रखें।
Real World Example
जब आप WhatsApp या Telegram जैसे chat application का use करते हैं, तो background में इसी तरह का TCP Server चलता है। वह हर user से connection accept करता है, messages receive करता है और दूसरे users तक पहुंचाता है — बिल्कुल वैसे ही जैसे हमने multi-threaded और NIO servers में देखा।
Summary Notes (for Quick Study)
- Primary class:
ServerSocket - Important methods:
accept(),close() - Advanced concept:
SelectorandChannelin NIO - Exam focus: Syntax + Concept + Communication Flow Diagram
