Home Java Example Java Io Java PipedInputStream and PipedOutputStream
Questions:Ask|Latest

 
 

Share on Google+Share on Google+

Java PipedInputStream and PipedOutputStream

Advertisement
In this section we will discuss about the PipedInputStream and PipedOutputStream in Java.

Java PipedInputStream and PipedOutputStream

In this section we will discuss about the PipedInputStream and PipedOutputStream in Java.

PipedInputStream and PipedOutputStream both are the Java classes provided in the java.io package. PipedOutputStream class writes the bytes data into the piped output stream and PipedInputStream reads the bytes data from the piped input stream. For writing to and reading from the streams the two individual threads are involved. One thread writes the bytes to the piped output stream and the other reads the bytes from the piped input stream. Never should try to use both PipedOutputStream and PipedInputStream object in a single thread this may cause for deadlocking of the thread. Actually the PipedOutputStream is a sender end of pipe which sends the data to the PipedInputStream end which is a receiver end, after writing the data bytes to the piped output stream then the PipedInputStream reads that data but, only when the piped input stream and piped output stream is connected to each other and createad a communication pipe.

Example :

An example is being given here into which I have used the both classes mentioned above. By giving this example I have tried to demonstrate you about how the data bytes are written into the piped output stream using one thread and how the other thread reads the data bytes from the piped input stream. In this example I have created a class named WriteFileOutputStreamExample1 which extends the Thread class. WriteFileOutputStreamExample1 first reads the data of a text file named 'abc.txt' and write them to the new text file named 'xyz.txt'. Again created a class named InputStreamExample which also extends the Thread class. The InputStreamExample class reads the bytes written into the 'xyz.txt' file. Then created a main class named PipedInputOutputStreamExample where created the objects of PipedOutputStream class and PipedInputStream class. In the PipedInputStream class object passes the reference of PipedOutputStream class to make a connection between both objects because the data can be read only when the communication pipe is created between the both objects.

Source Code :

WriteFileOutputStreamExample1.java

/*This example demonstrates that how
to write the data output stream to the 
FileOutputStream*/

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.File;
import java.io.OutputStream;

class WriteFileOutputStreamExample1 extends Thread
{

FileOutputStream fos1;
File file1 = new File("xyz.txt");

public WriteFileOutputStreamExample1()
{
}

public WriteFileOutputStreamExample1(OutputStream os)
{
   try
    {
       os = new FileOutputStream(file1);
    }
   catch(Exception ex)
    {
       System.out.println(ex);
    }
}

public void run()
{
       
       writeFile(file1);
       
}

   /*public static void main(String args[])
    {
       WriteFileOutputStreamExample1 wfose = new WriteFileOutputStreamExample1();
        wfose.start();
    }// end main
*/

   public void writeFile(File file)
   {
     FileInputStream fis = null;
       FileOutputStream fos = null;		
       try
          {
	fis = new FileInputStream("abc.txt");
	fos = new FileOutputStream(file);
	int r;
	System.out.println();
	System.out.println("******* Contents of abc.txt file has been written into the xyz.txt ***********");
	System.out.println();
	while((r= fis.read()) != -1)
	 {
	    fos.write(r);
	  }
	System.out.println();
           }
           catch(IOException e)
            {
	System.out.println("IOException caught..!!");
	e.printStackTrace();
             }
	finally
	 {
	    if(fis != null)
	     {
	       try
	         {
	           fis.close();
	         }
	       catch (IOException ioe)
	        {
		System.out.println(ioe);
	        }
	      if(fos != null)
                     {
                       try
                           {
		fos.close();
                           }
                          catch(IOException ie)
                            {
		     System.out.println(ie);
                            }
                       }
	     }
               }// end finally
         }// end writeFile()
}// end class

InputStreamExample.java

/*This example demonstrates that
how to read the data input stream*/

import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.File;

class InputStreamExample extends Thread
{
   File file1 = new File("xyz.txt");
   FileInputStream fis1;

  public InputStreamExample()
  {
  }

  public InputStreamExample(InputStream is)
   {
     try
       {
          is = new FileInputStream(file1);
       }
      catch(Exception ex)
       {
          System.out.println(ex);
       }
   }

  public void run()
   {
     readFile(file1);
   }

  /*public static void main(String args[])
   {     
      
       InputStreamExample ise = new InputStreamExample();
       ise.start();
   }// end main
*/

  public void readFile(File file)
   {
       InputStream is1 = null;
       FileInputStream fis = null;
       //file = new File();
       try
         {
            is1 = new FileInputStream(file);
            int c;
            System.out.println();
            System.out.println("reading text.....");
            while((c = is1.read() ) != -1)
	{
	   System.out.print((char) c);
	}
	System.out.println();
         }
     catch(IOException ioe)
        {
           System.out.println(ioe);
        }
     finally
        {
          if(is1 != null)
            {
               try
	   {
	     is1.close();
	   }
	catch(Exception e)
	   {
	      System.out.print(e);
	   }
           }  
       }// end finally
    }// end readFile()
}// end class

PipedInputOutputStreamExample.java

import java.io.*;

public class PipedInputOutputStreamExample {
       
    public static void main(String[] args) throws Exception {
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos);
        WriteFileOutputStreamExample1 wfose = new WriteFileOutputStreamExample1(pos);
        InputStreamExample ise = new InputStreamExample(pis);
        wfose.start();  //send data to the piped stream
        wfose.join();// Thread waits for writing the text into xyz.txt file
        ise.start();//read data from the currently written file which is in same piped stream

        // Closed the streams and released the resources              
        pis.close();
        pos.close();
    }
}

Output :

When you will execute the above example you will get the output as follows :

Download Source Code

Advertisements

If you enjoyed this post then why not add us on Google+? Add us to your Circles



Liked it!  Share this Tutorial


Follow us on Twitter, or add us on Facebook or Google Plus to keep you updated with the recent trends of Java and other open source platforms.

Posted on: December 11, 2012

Related Tutorials

Ask Questions?    Discuss: Java PipedInputStream and PipedOutputStream  

Post your Comment


Your Name (*) :
Your Email :
Subject (*):
Your Comment (*):
  Reload Image
 
 
Comments
DMCA.com