feat: implement PipedInputStream and PipedOutputStream with Producer-Consumer example

WHAT:
- Added PipedStreamExample demonstrating inter-thread communication using piped streams.
- Implemented Producer thread that writes integer data sequentially to a PipedOutputStream.
- Implemented Consumer thread that reads data from the connected PipedInputStream.
- Established continuous data exchange between Producer and Consumer with a delay.

WHY:
- Piped streams in Java (`PipedInputStream` and `PipedOutputStream`) are designed for
  thread-to-thread communication.
- This example models a classic producer-consumer problem using built-in stream constructs.
- Demonstrates synchronization of data flow without explicit shared objects.

HOW:
1. Created Producer class that writes incrementing integers to the output stream.
2. Created Consumer class that reads integers from the input stream and prints them.
3. Connected `PipedOutputStream` to `PipedInputStream` using `pis.connect(pos)`.
4. Started both threads to run concurrently with controlled sleep delays.

BENEFITS:
- Provides a clean mechanism for one thread to send data and another to receive it.
- Avoids explicit buffer management; streams handle data flow internally.
- Useful for pipeline-style processing where data is generated and consumed in parallel.

REAL-WORLD APPLICATIONS:
- Logging systems where one thread writes logs and another persists or processes them.
- Streaming applications where producers generate continuous data (e.g., sensors, real-time feeds).
- Threaded parsers or compilers that break work into producer-consumer stages.

NOTES:
- Both Producer and Consumer run indefinitely; in production systems,
  proper termination and resource cleanup should be added.
- Each `os.write(count)` writes only the low-order byte; for multi-byte values,
  DataOutputStream/DataInputStream should be used.
- Piped streams can throw `IOException` if either side closes unexpectedly.

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

Author: Someshdiwan

Section23JavaIOStreams/src/PipedStreamExample.java

@@ -3,11 +3,11 @@
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 
-// Producer class writes data to OutputStream
+// Producer class writes data to OutputStream.
 class Producer extends Thread {
     OutputStream os;
 
-    // Constructor to initialize OutputStream
+    // Constructor to initialize OutputStream.
     public Producer(OutputStream o) {
         this.os = o;
     }
@@ -16,10 +16,12 @@ public void run() {
         int count = 1;
         try {
             while (true) {
-                os.write(count); // Writing data to output stream
-                os.flush(); // Ensuring data is sent out
+                os.write(count); // Writing data to the output stream.
+                os.flush(); // Ensuring data is sent out.
+
                 System.out.println("Producer: " + count);
                 System.out.flush();
+
                 count++;
                 Thread.sleep(500);
             }
@@ -29,11 +31,11 @@ public void run() {
     }
 }
 
-// Consumer class reads data from InputStream
+// Consumer class reads data from InputStream.
 class Consumer extends Thread {
     InputStream is;
 
-    // Constructor to initialize InputStream
+    // Constructor to initialize InputStream.
     public Consumer(InputStream s) {
         this.is = s;
     }
@@ -55,18 +57,56 @@ public void run() {
 
 public class PipedStreamExample {
     public static void main(String[] args) throws Exception {
-        // Creating Piped Input and Output Streams
+        // Creating Piped Input and Output Streams.
         PipedInputStream pis = new PipedInputStream();
         PipedOutputStream pos = new PipedOutputStream();
 
-        // Connecting PipedInputStream to PipedOutputStream
+        // Connecting PipedInputStream to PipedOutputStream.
         pis.connect(pos);
 
         Producer p = new Producer(pos);
         Consumer c = new Consumer(pis);
 
-        // Starting Threads
         p.start();
         c.start();
     }
-}
+}
+
+/*
+1. Piped Streams:
+   - `PipedOutputStream` (Producer likhta hai) aur `PipedInputStream`
+      (Consumer padhta hai) ek doosre ke saath connect kiye jaate hain.
+   - Ek thread data write karta hai (Producer), dusra thread same data read karta hai (Consumer).
+   - Ye thread-to-thread communication ka ek tareeka hai Java IO me.
+
+2. Producer:
+   - Producer continuously numbers (1, 2, 3...) likhta hai `os.write(count)`.
+   - `flush()` ensure karta hai ki buffer me padha hua data consumer ko turant bhej diya jaye.
+   - `Thread.sleep(500)` → thoda delay deta hai taaki output readable ho.
+
+3. Consumer:
+   - Consumer continuously `is.read()` se Producer ka bheja hua data read karta hai.
+   - Jo bhi byte Producer bhejta hai, wahi yaha receive hota hai.
+   - `Thread.sleep(500)` → thoda delay, sync output ke liye.
+
+4. Main Method:
+   - `PipedInputStream pis = new PipedInputStream();`
+   - `PipedOutputStream pos = new PipedOutputStream();`
+   - Dono ko connect kiya gaya: `pis.connect(pos);`
+   - Producer ko `pos` diya gaya (write ke liye).
+   - Consumer ko `pis` diya gaya (read ke liye).
+   - Dono threads start hote hi ek pipeline jaise kaam karta hai.
+
+5. Output Pattern:
+   Producer: 1
+   Consumer: 1
+   Producer: 2
+   Consumer: 2
+   ... aur aise hi chalti rahegi.
+
+✔ `PipedOutputStream` → Producer likhta hai.
+✔ `PipedInputStream` → Consumer padhta hai.
+✔ Dono ko connect karke inter-thread communication hota hai.
+✔ Achha example Producer-Consumer problem ka using IO Streams.
+✔ Real-world use case: background threads jo ek doosre ko data stream karte hain.
+*/