Java - PipedReader ready() method

---

---

Description

The Java PipedReader ready() method tell whether this stream is ready to be read. A piped character stream is ready if the circular buffer is not empty. The ready() method checks whether the stream is ready to be read without blocking. It returns −

• true if data is available for reading,

• false if not (i.e., reading would block).

Declaration

Following is the declaration for java.io.PipedReader.ready() method.

public boolean ready()

Parameters

NA

Return Value

This method return the next character of data read.

Exception

IOException − If an I/O error occurs.

Example - Usage of PipedReader ready() method

This method returns true if the next read() is guaranteed not to block for input, false otherwise. Note that returning false does not guarantee that the next read will block.

PipedReaderDemo.java

package com.tutorialspoint;

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;

public class PipedReaderDemo {
   public static void main(String[] args) {
   
      // create a new Piped writer and reader
      PipedWriter writer = new PipedWriter();
      PipedReader reader = new PipedReader();

      try {
         // connect the reader and the writer
         reader.connect(writer);

         // write something
         writer.write(70);
         writer.write(71);

         // check if reader is ready to read
         System.out.println("" + reader.ready());

         // print the char array
         for (int i = 0; i < 2; i++) {
            System.out.println("" + (char) reader.read());
         }
      } catch (IOException ex) {
         ex.printStackTrace();
      }
   }
}

Output

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

true
F
G

Example - Check readiness before reading

The following example shows the usage of PipedReader ready() method.

PipedReaderDemo.java

package com.tutorialspoint;

import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.IOException;

public class PipedReaderDemo {
   public static void main(String[] args) {
      try {
         PipedReader reader = new PipedReader();
         PipedWriter writer = new PipedWriter(reader); // Connected

         writer.write("Hello");

         if (reader.ready()) {
            int ch = reader.read();
            System.out.println("Read character: " + (char) ch); // Should output 'H'
         } else {
            System.out.println("Reader not ready yet.");
         }

         writer.close();
         reader.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

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

Read character: H

Explanation

• After writing "Hello", the reader.ready() check confirms whether data is available.

• Helps avoid unnecessary blocking in IO operations.

• If true, it reads one character safely without blocking.

Example - Polling for readiness in a reader thread

The following example shows the usage of PipedReader ready() method.

PipedReaderDemo.java

package com.tutorialspoint;

import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.IOException;

public class PipedReaderDemo {
   public static void main(String[] args) throws IOException {
      PipedReader reader = new PipedReader();
      PipedWriter writer = new PipedWriter();
      reader.connect(writer);

      Thread producer = new Thread(() -> {
         try {
            Thread.sleep(1000); // Simulate delay
            writer.write("Async Message");
            writer.close();
         } catch (Exception e) {
            e.printStackTrace();
         }
      });

      Thread consumer = new Thread(() -> {
         try {
            System.out.println("Waiting for data...");
            while (!reader.ready()) {
               // Busy wait (in real code, you'd sleep or yield)
            }
            int ch;
            while ((ch = reader.read()) != -1) {
               System.out.print((char) ch); // Output: Async Message
            }
            reader.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      });

      producer.start();
      consumer.start();
   }
}

Output

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

Waiting for data...
Async Message

Explanation

• The consumer thread waits until reader.ready() returns true before calling read().

• This prevents the thread from blocking while waiting for the producer to write data.