1. class Read implements Runnable {
   
2.                         private PipedInputStream in;
   
3.                         Read(PipedInputStream in) {
   
4.                                 this.in = in;
   
5.                         }
   
6.                         public void run() {
   
7.                                 try {
   
8.                                         byte[] buf = new byte[1024];
   
9.                                         int len = in.read(buf);
   
10.                                         String s = new String(buf,0,len);
    
11.                                         System.out.println(s);
    
12.                                         in.close();
    
13.                                 }
    
14.                                 catch (IOException e) {
    
15.                                         throw new RuntimeException("读取失败");
    
16.                                 }
    
17.                         }
    
18. 
    
19.                 }
    
20.                 class Write implements Runnable {
    
21.                         private PipedOutputStream out;
    
22.                         Write(PipedOutputStream out) {
    
23.                                 this.out=out;
    
24.                         }
    
25.                         public void run() {
    
26.                                 try {
    
27.                                         out.write("piped lai la".getBytes());
    
28.                                         out.close();
    
29.                                 }
    
30.                                 catch (IOException e) {
    
31.                                         throw new RuntimeException("输出败");
    
32.                                 }
    
33.                         }
    
34.                 }
    
35.                 class PipedStreamDemo {
    
36.                         public static void main(String[] args)throws IOException {
    
37.                                 PipedInputStream  in  = new PipedInputStream();
    
38.                                 PipedOutputStream out = new PipedOutputStream();
    
39.                                 in.connect(out);
    
40. 
    
41.                                 Read r = new Read(in);
    
42.                                 Write w =new Write(out);
    
43.                                 new Thread(r).start();
    
44.                                 new Thread(w).start();
    
45.                         }
    
46.                 }
    

复制代码

这里使用了多线程，都说管道流是这边进那边出，现在使用多线程，如果输出那边抢到了执行权
但是还没有数据，为什么也能成功输出？????????

首先，要明白read()方法是一个阻塞式的方法，当没有读到数据时，就阻塞、等待，这时其他的线程就拿到了执行权。
在这个程序中，假如线程r先抢到了执行权，执行read（）方法，阻塞、等待，这时w线程就拿到了执行权，就会执行Write类中的run()方法中的任务，执行到write（）方法时，就会往PipeInputStream里面写入数据。当线程r再次获得了执行权后，执行read（）方法，发现有数据，这时就读取数据，完成任务。

class Read implements Runnable {
                        private PipedInputStream in;
                        Read(PipedInputStream in) {
                                this.in = in;
                        }
                        public void run() {
                                try {
                                        byte[] buf = new byte[1024];

                                         System.out.println("读取数据前，还没有阻塞");//
                                        int len = in.read(buf);//阻塞式方法，当执行到这里时，假如发现PipedInputStream中没有数据可读，那么阻塞、等待。
                                                                      //这时就会唤醒另外一个线程w， 并执行write（）方法，往PipedInputStream中写入数据。
                                         System.out.println("读取数据完成");//
                                        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 {
                                         System.out.println("准备写入数据，休眠5秒");//
                                          Thread.sleep(5000);
                                        out.write("piped lai la".getBytes());//写入数据
                                        out.close();
                                }
                                catch (Exception 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();
                        }
                }
在关键处加上了打印语句，希望可以帮助理解。

read()当没有读到数据时，便会阻塞、等待，  操作系统里面有详细的介绍可以看看，read方法是一个阻塞式的方法！