PipedOutputStream

By / 30 May 2025 / 2 minutes of reading

PipedOutputStream is a class in the java.io package used to write data to a communication pipe, where another thread can read the data using a connected PipedInputStream. Together, they form a producer-consumer style inter-thread communication channel.

This mechanism is helpful for simulating streaming, pipelines, or in-memory communication between threads without using shared memory or files.

Commonly Used Constructors and Methods

Simple Program – Inter-thread Communication

Mahesh writes data into a PipedOutputStream, and LotusJavaPrince reads it using PipedInputStream. This program demonstrates the basic usage of piped streams for communication between two threads.

import java.io.*;

public class SimplePipedStreamDemo {
    public static void main(String[] args) throws IOException {
        PipedOutputStream pout = new PipedOutputStream();
        PipedInputStream pin = new PipedInputStream(pout);

        Thread writer = new Thread(() -> {
            try {
                pout.write("Hello from Mahesh!".getBytes());
                pout.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        Thread reader = new Thread(() -> {
            try {
                int data;
                while ((data = pin.read()) != -1) {
                    System.out.print((char) data);
                }
                pin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        writer.start();
        reader.start();
    }
}
/*
Hello from Mahesh!
*/

Problem Statement:

LotusJavaPrince wants to create a simulation where Mahesh sends messages to him via a PipedOutputStream, and LotusJavaPrince receives them using a PipedInputStream. This program emulates a one-way chat between two threads.

import java.io.*;

class MaheshSender extends Thread {
    private final PipedOutputStream out;

    public MaheshSender(PipedOutputStream out) {
        this.out = out;
    }

    public void run() {
        String[] messages = {
            "Mahesh: Hi LotusJavaPrince!",
            "Mahesh: Are you ready for the Java exam?",
            "Mahesh: Let's meet at the library later."
        };

        try {
            for (String msg : messages) {
                out.write((msg + "\n").getBytes());
                Thread.sleep(1000);
            }
            out.close();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class LotusJavaPrinceReceiver extends Thread {
    private final PipedInputStream in;

    public LotusJavaPrinceReceiver(PipedInputStream in) {
        this.in = in;
    }

    public void run() {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("LotusJavaPrince received: " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class PipedChatSimulator {
    public static void main(String[] args) throws IOException {
        PipedOutputStream output = new PipedOutputStream();
        PipedInputStream input = new PipedInputStream(output);

        new MaheshSender(output).start();
        new LotusJavaPrinceReceiver(input).start();
    }
}

Output

LotusJavaPrince received: Mahesh: Hi LotusJavaPrince!
LotusJavaPrince received: Mahesh: Are you ready for the Java exam?
LotusJavaPrince received: Mahesh: Let's meet at the library later.

PipedOutputStream is not as commonly used as file streams or socket streams, but in scenarios where memory-based, real-time, thread-to-thread communication is required, it becomes an elegant and efficient solution.

Related Posts

Scroll to Top