Java - PipedInputStream class

---

---

Introduction

The Java PipedInputStream class is a piped input stream that can be connected to a piped output stream, the piped input stream then provides whatever data bytes are written to the piped output stream.Following are the important points about PipedInputStream −

• The piped input stream contains a buffer, decoupling read operations from write operations, within limits.

• Attempting to use both objects from a single thread is not recommended, as it may deadlock the thread.

• A pipe is said to be broken if a thread that was providing data bytes to the connected piped output stream is no longer alive.

Class declaration

Following is the declaration for Java.io.PipedInputStream class −

public class PipedInputStream
   extends InputStream

Field

Following are the fields for Java.io.PipedInputStream class −

• protected byte[] buffer − This is the circular buffer into which incoming data is placed.

• protected int in − This is the index of the position in the circular buffer at which the next byte of data will be stored when received from the connected piped output stream.

• protected int out − This is the index of the position in the circular buffer at which the next byte of data will be read by this piped input stream.

• protected static int PIPE_SIZE − This is the default size of the pipe's circular input buffer.

Class constructors

Class methods

Methods inherited

This class inherits methods from the following classes −

• Java.io.InputStream
• Java.io.Object

Example - Checking available bytes after writing data to a pipe

The following example shows the usage of PipedInputStream available() method.

PipedInputStreamDemo.java

package com.tutorialspoint;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;

public class PipedInputStreamDemo {
   public static void main(String[] args) {
      try {
         PipedOutputStream pos = new PipedOutputStream();
         PipedInputStream pis = new PipedInputStream(pos);

         pos.write("Hello".getBytes());

         // Check how many bytes are available to read
         int availableBytes = pis.available();
         System.out.println("Available bytes: " + availableBytes);  // Should print 5

         // Read the data
         byte[] buffer = new byte[availableBytes];
         pis.read(buffer);
         System.out.println("Data read: " + new String(buffer));

         pos.close();
         pis.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Available bytes: 5
Data read: Hello

Explanation

• available() returns the number of bytes that can be read without blocking.

• After writing "Hello" (5 bytes), available() returns 5.

• This is useful when you want to know how much data is ready for immediate reading.

Example - Closing PipedInputStream after reading data

The following example shows the usage of PipedInputStream close() method.

PipedInputStreamDemo.java

package com.tutorialspoint;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;

public class PipedInputStreamDemo {
   public static void main(String[] args) {
      try {
         // Create and connect piped streams
         PipedOutputStream pos = new PipedOutputStream();
         PipedInputStream pis = new PipedInputStream(pos);

         // Write some data
         pos.write("Hello, Pipe!".getBytes());

         // Read data from input stream
         byte[] buffer = new byte[pis.available()];
         pis.read(buffer);
         System.out.println("Read: " + new String(buffer));

         // Close the input stream
         pis.close();
         pos.close();

         System.out.println("PipedInputStream closed successfully.");
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Read: Hello, Pipe!
PipedInputStream closed successfully.

Explanation

• close() is used to release system resources associated with the input stream.

• After reading the data, the input stream is closed to prevent memory leaks or resource exhaustion.

• Always closing both ends of a pipe (PipedInputStream and PipedOutputStream) is best practice.

Example - Connecting PipedInputStream and PipedOutputStream manually

The following example shows the usage of PipedInputStream connect(PipedOutputStream src) method.

PipedInputStreamDemo.java

package com.tutorialspoint;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;

public class PipedInputStreamDemo {
   public static void main(String[] args) {
      try {
         PipedInputStream input = new PipedInputStream();
         PipedOutputStream output = new PipedOutputStream();

         // Manually connect input to output
         input.connect(output);

         // Write data from output
         output.write("Hello via pipe".getBytes());

         // Read the data using input
         byte[] buffer = new byte[input.available()];
         input.read(buffer);

         System.out.println("Received: " + new String(buffer));

         input.close();
         output.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Received: Hello via pipe

Explanation

• connect(PipedOutputStream pos) links the PipedInputStream to the specified PipedOutputStream.

• This is an alternative to the constructor-based connection (new PipedInputStream(output)).

• After connecting, data written to the output stream can be read from the input stream.