PipedInputStream

By / 30 May 2025 / 2 minutes of reading

PipedInputStream is used to read data written to a connected PipedOutputStream. It provides a communication pipe between two threads, enabling one thread to write data and another to read it.This class is part of Java’s inter-thread communication system and works in conjunction with PipedOutputStream.

Commonly Used Constructors and Methods

Simple Program – Inter-thread Communication

Mahesh writes data using PipedOutputStream, and LotusJavaPrince reads it using PipedInputStream. Demonstrate basic inter-thread communication.

import java.io.*;

public class SimplePipedExample {
    public static void main(String[] args) throws IOException {
        PipedInputStream pipedIn = new PipedInputStream();
        PipedOutputStream pipedOut = new PipedOutputStream(pipedIn);

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

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

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

Problem Statement:

LotusJavaPrince is building a live transaction processing system. Mahesh simulates transaction data and writes it using PipedOutputStream. LotusJavaPrince reads and processes transactions using PipedInputStream in real-time between two threads.

import java.io.*;

class TransactionWriter extends Thread {
    private final PipedOutputStream out;

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

    public void run() {
        String[] transactions = {
            "TXN001:Deposit:1000",
            "TXN002:Withdraw:500",
            "TXN003:Deposit:700"
        };
        try {
            for (String txn : transactions) {
                out.write((txn + "\n").getBytes());
                Thread.sleep(500); // simulate delay
            }
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class TransactionReader extends Thread {
    private final PipedInputStream in;

    public TransactionReader(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("Processing: " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class BankTransactionPipe {
    public static void main(String[] args) throws IOException {
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos);

        new TransactionWriter(pos).start();
        new TransactionReader(pis).start();
    }
}

Output

Processing: TXN001:Deposit:1000
Processing: TXN002:Withdraw:500
Processing: TXN003:Deposit:700Code language: CSS (css)

PipedInputStream enables efficient communication between threads.

  • Works together with PipedOutputStream.
  • Ideal for real-time, memory-based communication inside applications.
  • Supports blocking reads and helps build stream-like producer-consumer systems.

Related Posts

Scroll to Top