import java.io.*;
class Read implements Runnable
{
        private PipedInputStream in;
        Read(PipedInputStream in)
        {
                this.in = in;       
        }
        public void run()
        {
                try
                {
                        byte[] buf = new byte[1024];
                        int len = in.read(buf);

                        String s = new String(buf,0,len);

                        System.out.println(s);

                        in.close();
                }
                catch (IOException e)
                {
                        throw new RuntimeException("管道流读取失败");
                }
        }       
}

class Write implements Runnable
{
        private PipedOutputStream out;
        Write(PipedOutputStream out)
        {
                this.out = out;
        }
        public void run()
        {
                try
                {
                        out.write("piped管道来啦！".getBytes());
                        out.close();
                }
                catch (IOException e)
                {
                        throw new RuntimeException("管道流输出失败");
                }
        }
};

class PipedStreamDemo
{
        public static void main(String[] args) throws IOException
        {
                PipedInputStream in = new PipedInputStream();
                PipedOutputStream out = new PipedOutputStream();
                in.connect(out);

                Read r = new Read(in);
                Write w = new Write(out);
                new Thread(r).start();
                new Thread(w).start();
        }
};

下面代码可以实现，在Write的run方法中加入读取文件的流。代码优化的话，你可以在new Write对象的时候传入参数，比如你要读取哪个文件，

1. 
   
2. import java.io.*;
   
3. 
   
4. class Read implements Runnable
   
5. {
   
6.         private PipedInputStream in;
   
7.         Read(PipedInputStream in)
   
8.         {
   
9.                 this.in = in;
   
10.         }
    
11.         public void run()
    
12.         {
    
13.                 try
    
14.                 {
    
15.                         byte[] buf = new byte[1024];
    
16. 
    
17.                         //System.out.println("读取前。。没有数据阻塞");
    
18.                         int len = 0;
    
19.                         //System.out.println("读到数据。。阻塞结束");
    
20.                         while ((len=in.read(buf))!=-1)
    
21.                         {
    
22.                                 String s= new String(buf,0,len);
    
23.                                 System.out.println(s);
    
24.                         }
    
25.                         in.close();
    
26. 
    
27.                 }
    
28.                 catch (IOException e)
    
29.                 {
    
30.                         throw new RuntimeException("管道读取流失败");
    
31.                 }
    
32.         }
    
33. }
    
34. 
    
35. class Write implements Runnable
    
36. {
    
37.         private PipedOutputStream out;
    
38.         Write(PipedOutputStream out)
    
39.         {
    
40.                 this.out = out;
    
41.         }
    
42.         public void run()
    
43.         {
    
44.                 try
    
45.                 {
    
46.                         FileInputStream fis=new FileInputStream("d:\\2.java");
    
47.                         byte[] b=new byte[1024];
    
48.                         int len=0;
    
49.                         while ((len=fis.read(b))!=-1)
    
50.                         {
    
51.                                 out.write(b,0,len);
    
52.                         }
    
53.                         fis.close();
    
54.                         out.close();
    
55.                 }
    
56.                 catch (Exception e)
    
57.                 {
    
58.                         throw new RuntimeException("管道输出流失败");
    
59.                 }
    
60.         }
    
61. }
    
62. 
    
63. class  PipedStreamDemo
    
64. {
    
65.         public static void main(String[] args) throws IOException
    
66.         {
    
67.                 PipedInputStream in = new PipedInputStream();
    
68.                 PipedOutputStream out = new PipedOutputStream();
    
69.                 in.connect(out);
    
70. 
    
71.                 Read r = new Read(in);
    
72.                 Write w = new Write(out);
    
73.                 new Thread(r).start();
    
74.                 new Thread(w).start();
    
75. 
    
76. 
    
77.         }
    
78. }
    

复制代码