PipedInputStream和PipedOutputStream

http://jjd3ei.blog.163.com/blog/static/1995212642012116940210/

管道流类PipedInputStream类和PipedOutputStream类用于在应用程序中创建管道通信。一个PipedInputStream实例对象必须和PipedOutputStream实例对象进行连接而产生一个通信管道，PipedOutputsStream可以向管道中写入数据，PipedInputStream可以从管道中读取PipedOutputStream写入的数据，这两个类主要用来完成线程之间的通信，一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据。

 

下面来看一个两个线程之间互相通信的例子：

 

建一个发送者的类：

Sender.java

[java]  view plain copy

1. package com.richer.io;  
2.   
3. import java.io.IOException;  
4. import java.io.PipedOutputStream;  
5.   
6. /** 
7.  * 该类用于向另外一个线程发送数据，也就是发送者 
8.  * @author IsFung 
9.  */  
10. public class Sender extends Thread {  
11.     private PipedOutputStream outputStream = new PipedOutputStream(); //首先先创建一个发送对象  
12.   
13.     public PipedOutputStream getOutputStream() { //得到输出流  
14.         return outputStream;  
15.     }  
16.   
17.     public void run() {  
18.         String strInfo = new String("Hello! Welcome to my space!"); //发送的数据  
19.         try {  
20.             outputStream.write(strInfo.getBytes());  
21.             outputStream.close();  
22.         } catch (IOException e) {  
23.             e.printStackTrace();  
24.         }  
25.           
26.     }  
27.       
28. }  

再建一个接收者的类：

Receiver.java

[java]  view plain copy

1. package com.richer.io;  
2.   
3. import java.io.IOException;  
4. import java.io.PipedInputStream;  
5. /** 
6.  * 接收者 
7.  * @author IsFung 
8.  */  
9. public class Receiver extends Thread {  
10.     private PipedInputStream inputStream = new PipedInputStream();// 读取对象  
11.   
12.     public PipedInputStream getInputStream() {  
13.         return inputStream;  
14.     }  
15.   
16.     public void run() {  
17.         byte[] bytes = new byte[1024];  
18.   
19.         try {  
20.             int length = inputStream.read(bytes);// 接收数据  
21.             System.out.println("接收到的信息如下:/n" + new String(bytes, 0, length));// 打印出收到的信息  
22.             inputStream.close();  
23.         } catch (IOException e) {  
24.             e.printStackTrace();  
25.         }  
26.     }  
27.   
28. }  

最后我们编写一个控制程序：

PipedStreamTest.java

[java]  view plain copy

1. package com.richer.io;  
2.   
3. import java.io.IOException;  
4. import java.io.PipedInputStream;  
5. import java.io.PipedOutputStream;  
6.   
7. public class PipedStreamTest {  
8.   
9.     /** 
10.      *控制程序 
11.      * @param args 
12.      */  
13.     public static void main(String[] args) {  
14.         Sender sender = new Sender();  
15.         Receiver receiver = new Receiver();  
16.           
17.         PipedOutputStream outputStream = sender.getOutputStream();  
18.         PipedInputStream inputStream = receiver.getInputStream();  
19.           
20.         try {  
21.             //两个管道相连接  
22.             //inputStream.connect(outputStream); 这2种都可以  
23.             outputStream.connect(inputStream);  
24.         } catch (IOException e) {  
25.             e.printStackTrace();  
26.         }  
27.         //启动线程  
28.         sender.start();  
29.         receiver.start();  
30.     }  
31.   
32. }  

 

运行该程序的时候应该会在命令行输出以下信息：

 

接收到的信息如下:

Hello! Welcome to my space!

 

另外，JDK还提供了PipedReader和PipedWriter类，用来处理字符文本的管道通信。它们和PipedInputStream类和PipedOutputStream类使用方法很类似，这里Richer就不多介绍了。

 

使用管道流类可以实现各个程序模块之间的松耦合通信，使用管道流类进行通信的模块，具有强内聚弱耦合的特点，一块模块被替换不会影响到其他的模块。这样就可以在程序中灵活的将多个这样的模块的输入流和输出流相连，以拼装成满足各种应用的程序，而不用对模块内部进行修改。上面例子程序中的Sender和Receiver的输入和输出管道相连，Sender发送的数据就被Receiver接收到了。

 

版权声明： 原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。