1. import java.io.*;
   
2. 
   
3. class Read implements Runnable
   
4. {
   
5.         private PipedInputStream in;
   
6.         Read(PipedInputStream in)
   
7.         {
   
8.                 this.in = in;
   
9.         }
   
10.         public void run()
    
11.         {
    
12.                 try
    
13.                 {
    
14.                         byte[] buf =new byte[1024];
    
15.                         
    
16. 
    
17.                         System.out.println("读取前。。没有数据阻塞");
    
18.                         int len = in.read(buf);
    
19.                         System.out.println("读到数据。。阻塞结束");
    
20. 
    
21. 
    
22. 
    
23.                         String s= new String(buf,0,len);
    
24. 
    
25.                         System.out.println(s);
    
26. 
    
27.                         in.close();
    
28. 
    
29.                 }
    
30.                 catch (IOException e)
    
31.                 {
    
32.                         throw new RuntimeException("管道读取流失败");
    
33.                 }
    
34.         }
    
35. }
    
36. 
    
37. class Write implements Runnable
    
38. {
    
39.         private PipedOutputStream out;
    
40.         Write(PipedOutputStream out)
    
41.         {
    
42.                 this.out = out;
    
43.         }
    
44.         public void run()
    
45.         {
    
46.                 try
    
47.                 {
    
48.                         System.out.println("开始写入数据，等待6秒后。");
    
49.                         Thread.sleep(6000);
    
50.                         out.write("piped lai la".getBytes());
    
51.                         out.close();
    
52.                 }
    
53.                 catch (Exception e)
    
54.                 {
    
55.                         throw new RuntimeException("管道输出流失败");
    
56.                 }
    
57.         }
    
58. }
    
59. 
    
60. public class  PipedStreamDemo
    
61. {
    
62.         public static void main(String[] args) throws IOException
    
63.         {
    
64. 
    
65.                 PipedInputStream in = new PipedInputStream();
    
66.                 PipedOutputStream out = new PipedOutputStream();
    
67.                 in.connect(out);                                                      //此处可改为out.connect(in),执行结果相同
    
68.                                                                                               //这是说明管道流中的数据时由PipedOutputStream对象输入，
    
69.                                                                                               //PipedInputStream对象输出。而且只有这一中传输方向？
    
70.                 Read r = new Read(in);
    
71.                 Write w = new Write(out);
    
72.                 new Thread(r).start();
    
73.                 new Thread(w).start();
    
74. 
    
75. 
    
76.         }
    
77. }
    

复制代码

看完了代码，再往下一看，吓我一跳，问题呢？
如果？前是问题的话，，，，那么也就是结果，，，你自己都已经总结出来了。。。。。。。{:soso_e127:}

out.connect(in)与in.connect(out)效果一样，都是连接管道，无所谓方向问题，因为输入流是阻塞线程，没有输入数据时，它会等待，宏观上来说它是最后执行的。这个程序里，输出流写了一些数据到管道，所以它也输入了，输入流到管道读到取数据显示到控制台，所以它也输出了