今天看到毕老师第21的视频，模仿视频写了一个使用管道流的程序

但是抛出了两个异常，自己解决了一个，该有一个我找不到解决的办法，大神帮我看看怎么解决。。

3Q

1. package day21;
   
2. 
   
3. import java.io.IOException;
   
4. import java.io.PipedInputStream;
   
5. import java.io.PipedOutputStream;
   
6. 
   
7. class ReaderPip implements Runnable {
   
8.         private PipedInputStream pis;
   
9. 
   
10.         ReaderPip(PipedInputStream pis) {
    
11.                 this.pis = pis;
    
12.         }
    
13. 
    
14.         public void run() {
    
15.                 try {
    
16.                         byte[] bt = new byte[1024];
    
17.                         int len = 0;
    
18.                         while ((len = pis.read(bt)) != -1) {
    
19.                                 String str = new String(bt, 0, len);
    
20.                                 System.out.println(str);
    
21.                         }
    
22.                 } catch (IOException e) {
    
23.                         e.printStackTrace();
    
24.                         // throw new RuntimeException("reader fail");
    
25.                 } finally {
    
26.                         try {
    
27.                                 pis.close();
    
28. 
    
29.                         } catch (IOException e) {
    
30.                                 e.printStackTrace();
    
31.                         }
    
32.                 }
    
33. 
    
34.         }
    
35. }
    
36. 
    
37. class WritePip implements Runnable {
    
38.         private PipedOutputStream pos;
    
39. 
    
40.         WritePip(PipedOutputStream pos) {
    
41.                 this.pos = pos;
    
42.         }
    
43. 
    
44.         public void run() {
    
45.                 try {
    
46.                         pos.write("嘿咻嘿咻。。。".getBytes());
    
47.                        
    
48.                 } catch (IOException e) {
    
49.                         e.printStackTrace();
    
50.                 } finally {
    
51.                         try {
    
52.                                 pos.close();
    
53.                         } catch (IOException e) {
    
54.                                 e.printStackTrace();
    
55.                         }
    
56.                 }
    
57.         }
    
58. }
    
59. 
    
60. public class PipedStreamDemo {
    
61.         public static void main(String args[]) {
    
62.                 PipedInputStream pis = new PipedInputStream();
    
63.                 PipedOutputStream pos = new PipedOutputStream();
    
64.                 try {
    
65.                         pis.connect(pos);
    
66.                         new Thread(new ReaderPip(pis)).start();
    
67.                         new Thread(new WritePip(pos)).start();
    
68. 
    
69.                 } catch (IOException e) {
    
70.                         e.printStackTrace();
    
71.                 } finally {
    
72.                         try {
    
73.                                 pis.close();
    
74.                         } catch (IOException e) {
    
75.                                 e.printStackTrace();
    
76.                         } finally {
    
77.                                 try {
    
78.                                         pos.close();
    
79.                                 } catch (IOException e) {
    
80.                                         e.printStackTrace();
    
81.                                 }
    
82.                         }
    
83.                 }
    
84.         }
    
85. }

复制代码

异常提醒如下：
java.io.IOException: Pipe closed
        at java.io.PipedInputStream.checkStateForReceive(PipedInputStream.java:244)
        at java.io.PipedInputStream.receive(PipedInputStream.java:210)
        at java.io.PipedOutputStream.write(PipedOutputStream.java:132)
        at java.io.OutputStream.write(OutputStream.java:58)
        at day21.WritePip.run(PipedStreamDemo.java:46)
        at java.lang.Thread.run(Thread.java:619)

更改后的代码如下：
class ReaderPip implements Runnable {
        private PipedInputStream pis;

        ReaderPip(PipedInputStream pis) {
                this.pis = pis;
        }

        public void run() {
                try {
                        byte[] bt = new byte[1024];
                        int len = 0;
                        while ((len = pis.read(bt)) != -1) {
                                String str = new String(bt, 0, len);
                                System.out.println(str);
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                        // throw new RuntimeException("reader fail");
                } finally {
                        try {
                                pis.close();

                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }

        }
}

class WritePip implements Runnable {
        private PipedOutputStream pos;

        WritePip(PipedOutputStream pos) {
                this.pos = pos;
        }

        public void run() {
                try {
                        pos.write("嘿咻嘿咻。。。".getBytes());
                        
                } catch (IOException e) {
                        e.printStackTrace();
                } finally {
                        try {
                                pos.close();
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
        }
}

public class PipedStreamDemo {
        public static void main(String args[]) {
                PipedInputStream pis = new PipedInputStream();
                PipedOutputStream pos = new PipedOutputStream();      
                        try {
                                                        pis.connect(pos);
                                                } catch (IOException e) {
                                                        // TODO Auto-generated catch block
                                                        e.printStackTrace();
                                                }
                        new Thread(new ReaderPip(pis)).start();
                        new Thread(new WritePip(pos)).start();

        }
}
原因是因为你前面已经把流关闭了，后面又把流关闭了一次

终结者 发表于 2013-11-21 14:06
更改后的代码如下：
class ReaderPip implements Runnable {
        private PipedInputStream pis;

这个真没注意到

谢了 哥们，，

如果问题已经解决，请及时修改主题为“提问结束”。
修改主题的方法链接
http://bbs.itheima.com/thread-89313-1-1.html
如果没有解决，可能你的问题问得不够清楚。可以重新发问的哦~

FFF 发表于 2013-11-21 18:26
如果问题已经解决，请及时修改主题为“提问结束”。
修改主题的方法链接
http://bbs.itheima.com/thread-89 ...

3F哥  3Q for zhe JiShuFen