feat(reverse-echo): add multithreaded TCP reverse-echo server and client example with I/O details

What
- Added ReverseEcho: a multithreaded TCP server that accepts multiple client connections on port 6000.
- Each client is handled by a dedicated Thread subclass (ReverseEcho) which:
  - uses BufferedReader(InputStreamReader(socket.getInputStream())) to read text lines from client,
  - uses PrintStream(socket.getOutputStream()) to send text responses,
  - reverses each incoming line using StringBuilder.reverse() and returns it back to the client,
  - uses a simple sentinel "dne" to terminate per-connection loop and close the socket.
- Included an inner Client example showing how to connect to the server, send keyboard input, and receive reversed responses.
- Documented why BufferedReader is used, how the server accepts connections in an infinite loop, and where to change the address/port.

Why
- Demonstrates core TCP server patterns:
  - ServerSocket.accept() to accept incoming connections,
  - per-connection thread model to enable concurrent clients,
  - use of character streams (BufferedReader) for line-oriented protocols,
  - use of PrintStream for simple line output.
- Educational example for learning blocking I/O, thread-per-connection model, and simple request/response protocols.
- Provides a minimal, clear pattern to build or test line-based services (chat bots, small REPL servers, command servers).

How to use
1. Start the server:
   - Run ReverseEcho.main(). Server listens on port 6000 and prints connection counts.
2. Start a client:
   - Replace the placeholder IP in Client.main() with server IP (for local tests use "localhost").
   - Run Client.main(). Type lines at the keyboard; the server will echo each line reversed.
3. Protocol details:
   - Client sends newline-terminated text lines.
   - Server responds with newline-terminated reversed text lines.
   - Send the exact string "dne" (without quotes) to terminate the session from either side (server closes socket on "dne").
4. Example session:
   - Client: Hello
   - Server: olleH
   - Client: world
   - Server: dlrow
   - Client: dne
   - Connection closed.

Real-life applications
- Teaching and testing TCP basics, socket programming and stream I/O.
- Lightweight text-processing backends (e.g., simple command processors, protocol simulators).
- Local development tools for debugging and learning about concurrency, timeouts and network flows.

Notes & recommendations
- BufferedReader is wrapped around InputStreamReader to efficiently read lines and handle character decoding.
- PrintStream is convenient for println() but consider using BufferedWriter/PrintWriter with explicit flushing for production code.
- Current server uses one thread per client. For many simultaneous clients, prefer a thread pool (ExecutorService) or NIO (java.nio) for scalability.
- The code currently swallows exceptions silently in run(); add proper logging and resource cleanup.
- The sentinel "dne" is a simple protocol choice for demo purposes—use formal protocol framing and validation for production systems.
- Always validate input and consider timeouts (socket read timeout) to prevent blocked threads.
- Consider graceful shutdown handling for ServerSocket (e.g., listening flag + close) instead of infinite loop.
- Security: do not trust client input; avoid exposing sensitive operations over plain TCP. Use TLS (SSLSocket) for encrypted communication in real deployments.

Possible improvements (next steps)
- Replace per-connection Thread with ExecutorService to limit max threads.
- Add socket timeouts and per-connection exception handling/logging.
- Switch to non-blocking NIO for high-concurrency use cases.
- Add graceful server shutdown hook and connection tracking.
- Replace sentinel-based termination with a formal request/response code or protocol.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section27NetworkProgramming/ReverseEchoServerMultipleClient/src/MultiClient/ReverseEcho.java

@@ -20,14 +20,21 @@ public void run() {
 
             //Waiting to accept the connection.
             //For using Readline(); we are using Buffer reader();
-            //BufferedReader to read input from client
+
+            //BufferedReader to read input from a client
             BufferedReader br = new BufferedReader(new InputStreamReader(stk.getInputStream()));
-            //Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
-            //The buffer size may be specified, or the default size may be used. The default is large enough for most purposes.
-            //In general, each read request made of a Reader causes a corresponding read request to be made of the underlying character or byte stream.
-            //It is therefore advisable to wrap a BufferedReader around any Reader whose read() operations may be costly, such as FileReaders and InputStreamReaders.
-            PrintStream ps = new PrintStream(stk.getOutputStream());
+            /*
+            Reads text from a character-input stream, buffering characters to provide for the efficient reading of
+            characters, arrays, and lines.
+            The buffer size may be specified, or the default size may be used. The default is large enough for most
+            purposes.
+            In general, each read request made of a Reader causes a corresponding read request to be made of the
+            underlying character or byte stream.
+            It is therefore advisable to wrap a BufferedReader around any Reader whose read() operations may be
+            costly, such as FileReaders and InputStreamReaders.
+            */
 
+            PrintStream ps = new PrintStream(stk.getOutputStream());
 
             String msg;
             StringBuilder sb;
@@ -49,18 +56,20 @@ public void run() {
 
     // Main server method to accept multiple client connections
     public static void main(String[] args) throws Exception {
-        /*Now, we want to allow server multiple client using multi threading.
+        /*
+        Now, we want to allow a server multiple client using multi threading.
         Client ------ Server
         Network --IP Add
         Transport layer ==Establish connection
         Connection-Oriented server.
-        Client software will communicate server soft which are on other machine.
+        Client software will communicate with server software that is on another machine.
         Server -- PORT Number 6000.
-        Client need Server IP and port address. to connect the server*/
-
+        Client needs Server IP and port address. to connect the server
+        */
 
         ServerSocket ss = new ServerSocket(6000);
-        //Accept the connection and it should now gave connection to the thread.
+        //Accept the connection, and it should now give connection to the thread.
+
         Socket stk;
         ReverseEcho re; //references
 
@@ -74,18 +83,19 @@ public static void main(String[] args) throws Exception {
             re = new ReverseEcho(stk); //Creating and object here.
             re.start();
         }
-        while (true); //Server is running Infinitely. most of the server running in infinite loop.
+        while (true);
+        //Server is running Infinitely. most of the servers running in infinite loop.
     }
 
-    //Client connected to server
+    //Client connected to server.
     public static class Client {
         public static void main(String[] args) throws Exception {
 
             //Input and out put stream for socket Connection.
             Socket stk = new Socket("Add Your IP Address, Go CMD type ipconfig", 6000);
             System.out.println("Connected to the server.");
 
-            //KeyBoard Stream
+            //KeyBoard Stream.
             BufferedReader keyb = new BufferedReader(new InputStreamReader(System.in));
 
 
@@ -118,6 +128,6 @@ public static void main(String[] args) throws Exception {
 Client:
 Connects to the server at IP Add Your IP Address, Go CMD type ipconfig on port 6000.
 Reads input from the keyboard, sends it to the server.
-Receives reversed message from the server and displays it.
+Receives a reversed message from the server and displays it.
 Continues until "dne" is entered, then closes the connection.
-*/
+*/