Java-IO之PipedReader和PipedWriter

最新推荐文章于 2021-02-02 22:59:41 发布

javaPie

最新推荐文章于 2021-02-02 22:59:41 发布

阅读量343

点赞数

分类专栏： JAVA IO

JAVA IO 专栏收录该内容

25 篇文章

订阅专栏

本文介绍Java IO中的PipedReader和PipedWriter，它们用于实现线程间的数据通讯。通过示例代码展示了如何使用这两种类进行数据传递。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java-IO之PipedReader和PipedWriter

标签： Java IO PipedReader PipedWriter

2016-10-04 18:27 889人阅读评论(0) 收藏举报

分类：

Java-IO（22）

PipedReader和PipedWriter与PipedInputStream和PipedOutputStream一样，都可以用于管道通信。PipedWriter是字符管道输出流，继承于Writer；PipedReader是字符管道输入流，继承于Reader，PipedWriter和PipedReader的作用是可以通过管道进行线程间的通讯。两者必须要配套使用。

示例程序：

[java]view plaincopy 
    
print?
 public class Receiver extends Thread {  
   
     // 管道输入流对象。  
     // 它和“管道输出流(PipedWriter)”对象绑定，  
     // 从而可以接收“管道输出流”的数据，再让用户读取。  
     private PipedReader in = new PipedReader();  
   
     // 获得“管道输入流对象”  
     public PipedReader getReader()  
     {  
         return in;  
     }  
   
     @Override  
     public void run(){  
         readMessageOnce() ;  
         //readMessageContinued() ;  
     }  
   
     // 从“管道输入流”中读取1次数据  
     public void readMessageOnce(){  
         // 虽然buf的大小是2048个字符，但最多只会从“管道输入流”中读取1024个字符。  
         // 因为，“管道输入流”的缓冲区大小默认只有1024个字符。  
         char[] buf = new char[2048];  
         try {  
             int len = in.read(buf);  
             System.out.println(new String(buf,0,len));  
             in.close();  
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
     }  
   
     // 从“管道输入流”读取>1024个字符时，就停止读取  
     public void readMessageContinued()  
     {  
         int total=0;  
         while(true) {  
             char[] buf = new char[1024];  
             try {  
                 int len = in.read(buf);  
                 total += len;  
                 System.out.println(new String(buf,0,len));  
                 // 若读取的字符总数>1024，则退出循环。  
                 if (total > 1024)  
                         break;  
                 } catch (IOException e) {  
                     e.printStackTrace();  
                 }  
         }  
   
         try {  
             in.close();  
         } catch (IOException e) {  
                 e.printStackTrace();  
         }  
     }  
 }  

[java]view plaincopy 
    
print?
 public class Sender extends Thread {  
     // 管道输出流对象。  
     // 它和“管道输入流(PipedReader)”对象绑定，  
     // 从而可以将数据发送给“管道输入流”的数据，然后用户可以从“管道输入流”读取数据。  
     private PipedWriter out = new PipedWriter();  
     // 获得“管道输出流”对象  
     public PipedWriter getWriter(){  
         return out;  
     }  
   
     @Override  
     public void run(){  
         writeShortMessage();  
         //writeLongMessage();  
     }  
   
     // 向“管道输出流”中写入一则较简短的消息："this is a short message"   
     private void writeShortMessage() {  
         String strInfo = "this is a short message" ;  
         try {  
             out.write(strInfo.toCharArray());  
             out.close();  
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
     }  
     // 向“管道输出流”中写入一则较长的消息  
     private void writeLongMessage() {  
         StringBuilder sb = new StringBuilder();  
         // 通过for循环写入1020个字符  
         for (int i=0; i<102; i++)  
             sb.append("0123456789");  
             // 再写入26个字符。  
             sb.append("abcdefghijklmnopqrstuvwxyz");  
             // str的总长度是1020+26=1046个字符  
             String str = sb.toString();  
         try {  
             // 将1046个字符写入到“管道输出流”中  
             out.write(str);  
             out.close();  
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
     }  
 }  

[java]view plaincopy 
    
print?
 public class PipeTest {  
   
     public static void main(String[] args) {     
         Sender t1 = new Sender();     
   
         Receiver t2 = new Receiver();     
   
         PipedWriter out = t1.getWriter();     
   
         PipedReader in = t2.getReader();  
         try {     
             //管道连接。下面2句话的本质是一样。  
             //out.connect(in);     
             in.connect(out);     
   
             /**   
             * Thread类的START方法：   
             * 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。    
             * 结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）和另一个线程（执行其 run 方法）。    
             * 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。    
             */  
             t1.start();  
             t2.start();  
         } catch (IOException e) {  
              e.printStackTrace();  
         }  
     }  
 }  

输出结果：

this is a short message

基于JDK8的PipedReader的源码：

[java]view plaincopy 
    
print?
 public class PipedReader extends Reader {  
     boolean closedByWriter = false;  
     boolean closedByReader = false;  
     boolean connected = false;  
   
     /* REMIND: identification of the read and write sides needs to be 
        more sophisticated.  Either using thread groups (but what about 
        pipes within a thread?) or using finalization (but it may be a 
        long time until the next GC). */  
     Thread readSide;  
     Thread writeSide;  
   
     /** 
      * The size of the pipe's circular input buffer. 
      */  
     //默认的输入缓冲大小为1024  
     private static final int DEFAULT_PIPE_SIZE = 1024;  
   
     /** 
      * The circular buffer into which incoming data is placed. 
      */  
     //字符数组  
     char buffer[];  
   
     /** 
      * The index of the position in the circular buffer at which the 
      * next character of data will be stored when received from the connected 
      * piped writer. <code>in<0</code> implies the buffer is empty, 
      * <code>in==out</code> implies the buffer is full 
      */  
     //输入标志位  
     int in = -1;  
   
     /** 
      * The index of the position in the circular buffer at which the next 
      * character of data will be read by this piped reader. 
      */  
     //输出标志位，in==out表示为满  
     int out = 0;  
     //构造函数  
     public PipedReader(PipedWriter src) throws IOException {  
         this(src, DEFAULT_PIPE_SIZE);  
     }  
     //构造函数，有管道大小  
     public PipedReader(PipedWriter src, int pipeSize) throws IOException {  
         initPipe(pipeSize);  
         connect(src);  
     }  
     //没有连接，必须链接才行  
     public PipedReader() {  
         initPipe(DEFAULT_PIPE_SIZE);  
     }  
     public PipedReader(int pipeSize) {  
         initPipe(pipeSize);  
     }  
     //构建pipeSize大小的字符缓冲区  
     private void initPipe(int pipeSize) {  
         if (pipeSize <= 0) {  
             throw new IllegalArgumentException("Pipe size <= 0");  
         }  
     buffer = new char[pipeSize];  
     }  
     //Reader与Writer连接  
     public void connect(PipedWriter src) throws IOException {  
         src.connect(this);  
     }  
   
     /** 
      * Receives a char of data. This method will block if no input is 
      * available. 
      */  
     //接受数据，  
     synchronized void receive(int c) throws IOException {  
         if (!connected) {  
                 throw new IOException("Pipe not connected");  
         } else if (closedByWriter || closedByReader) {  
                 throw new IOException("Pipe closed");  
         } else if (readSide != null && !readSide.isAlive()) {  
                 throw new IOException("Read end dead");  
         }  
   
         writeSide = Thread.currentThread();  
         while (in == out) {  
             if ((readSide != null) && !readSide.isAlive()) {  
                 throw new IOException("Pipe broken");  
             }  
         /* full: kick any waiting readers */  
         notifyAll();  
             try {  
                 wait(1000);  
             } catch (InterruptedException ex) {  
                 throw new java.io.InterruptedIOException();  
             }  
         }  
         if (in < 0) {  
             in = 0;  
             out = 0;  
         }  
         buffer[in++] = (char) c;  
         if (in >= buffer.length) {  
             in = 0;  
         }  
     }  
   
     /** 
      * Receives data into an array of characters.  This method will 
      * block until some input is available. 
      */  
     synchronized void receive(char c[], int off, int len)  throws IOException {  
         while (--len >= 0) {  
             receive(c[off++]);  
         }  
     }  
   
     /** 
      * Notifies all waiting threads that the last character of data has been 
      * received. 
      */  
     synchronized void receivedLast() {  
         closedByWriter = true;  
         notifyAll();  
     }  
   
     /** 
      * Reads the next character of data from this piped stream. 
      * If no character is available because the end of the stream 
      * has been reached, the value <code>-1</code> is returned. 
      * This method blocks until input data is available, the end of 
      * the stream is detected, or an exception is thrown. 
      * 
      * @return     the next character of data, or <code>-1</code> if the end of the 
      *             stream is reached. 
      * @exception  IOException  if the pipe is 
      *          <a href=PipedInputStream.html#BROKEN> <code>broken</code></a>, 
      *          {@link #connect(java.io.PipedWriter) unconnected}, closed, 
      *          or an I/O error occurs. 
      */  
     public synchronized int read()  throws IOException {  
         if (!connected) {  
             throw new IOException("Pipe not connected");  
         } else if (closedByReader) {  
             throw new IOException("Pipe closed");  
         } else if (writeSide != null && !writeSide.isAlive()  
                 && !closedByWriter && (in < 0)) {  
             throw new IOException("Write end dead");  
         }  
   
         readSide = Thread.currentThread();  
         int trials = 2;  
         while (in < 0) {  
             if (closedByWriter) {  
                 /* closed by writer, return EOF */  
                 return -1;  
             }  
             if ((writeSide != null) && (!writeSide.isAlive()) && (--trials < 0)) {  
                 throw new IOException("Pipe broken");  
             }  
             /* might be a writer waiting */  
             notifyAll();  
             try {  
                 wait(1000);  
             } catch (InterruptedException ex) {  
                 throw new java.io.InterruptedIOException();  
             }  
         }  
         int ret = buffer[out++];  
         if (out >= buffer.length) {  
             out = 0;  
         }  
         if (in == out) {  
             /* now empty */  
             in = -1;  
         }  
         return ret;  
     }  
   
     /** 
      * Reads up to <code>len</code> characters of data from this piped 
      * stream into an array of characters. Less than <code>len</code> characters 
      * will be read if the end of the data stream is reached or if 
      * <code>len</code> exceeds the pipe's buffer size. This method 
      * blocks until at least one character of input is available. 
      * 
      * @param      cbuf     the buffer into which the data is read. 
      * @param      off   the start offset of the data. 
      * @param      len   the maximum number of characters read. 
      * @return     the total number of characters read into the buffer, or 
      *             <code>-1</code> if there is no more data because the end of 
      *             the stream has been reached. 
      * @exception  IOException  if the pipe is 
      *                  <a href=PipedInputStream.html#BROKEN> <code>broken</code></a>, 
      *                  {@link #connect(java.io.PipedWriter) unconnected}, closed, 
      *                  or an I/O error occurs. 
      */  
     public synchronized int read(char cbuf[], int off, int len)  throws IOException {  
         if (!connected) {  
             throw new IOException("Pipe not connected");  
         } else if (closedByReader) {  
             throw new IOException("Pipe closed");  
         } else if (writeSide != null && !writeSide.isAlive()  
                 && !closedByWriter && (in < 0)) {  
             throw new IOException("Write end dead");  
         }  
   
         if ((off < 0) || (off > cbuf.length) || (len < 0) ||((off + len) > cbuf.length) || ((off + len) < 0)) {  
             throw new IndexOutOfBoundsException();  
         } else if (len == 0) {  
             return 0;  
         }  
   
         /* possibly wait on the first character */  
         int c = read();  
         if (c < 0) {  
             return -1;  
         }  
         cbuf[off] =  (char)c;  
         int rlen = 1;  
         while ((in >= 0) && (--len > 0)) {  
             cbuf[off + rlen] = buffer[out++];  
             rlen++;  
             if (out >= buffer.length) {  
                 out = 0;  
             }  
             if (in == out) {  
                 /* now empty */  
                 in = -1;  
             }  
         }  
         return rlen;  
     }  
   
     /** 
      * Tell whether this stream is ready to be read.  A piped character 
      * stream is ready if the circular buffer is not empty. 
      * 
      * @exception  IOException  if the pipe is 
      *                  <a href=PipedInputStream.html#BROKEN> <code>broken</code></a>, 
      *                  {@link #connect(java.io.PipedWriter) unconnected}, or closed. 
      */  
     //是否准备好可以读  
     public synchronized boolean ready() throws IOException {  
         if (!connected) {  
             throw new IOException("Pipe not connected");  
         } else if (closedByReader) {  
             throw new IOException("Pipe closed");  
         } else if (writeSide != null && !writeSide.isAlive()&& !closedByWriter && (in < 0)) {  
             throw new IOException("Write end dead");  
         }  
         if (in < 0) {  
             return false;  
         } else {  
             return true;  
         }  
     }  
   
     /** 
      * Closes this piped stream and releases any system resources 
      * associated with the stream. 
      * 
      * @exception  IOException  if an I/O error occurs. 
      */  
     //关闭管道流，释放资源  
     public void close()  throws IOException {  
         in = -1;  
         closedByReader = true;  
     }  
 }  

基于JDK8的PipedWriter源码：

[java]view plaincopy 
    
print?
 public class PipedWriter extends Writer {  
   
         /* REMIND: identification of the read and write sides needs to be 
        more sophisticated.  Either using thread groups (but what about 
        pipes within a thread?) or using finalization (but it may be a 
        long time until the next GC). */  
         private PipedReader sink;  
   
     /* This flag records the open status of this particular writer. It 
      * is independent of the status flags defined in PipedReader. It is 
      * used to do a sanity check on connect. 
      */  
     private boolean closed = false;  
   
     /** 
      * Creates a piped writer connected to the specified piped 
      * reader. Data characters written to this stream will then be 
      * available as input from <code>snk</code>. 
      * 
      * @param      snk   The piped reader to connect to. 
      * @exception  IOException  if an I/O error occurs. 
      */  
     //构造函数，连接Reader  
     public PipedWriter(PipedReader snk)  throws IOException {  
         connect(snk);  
     }  
   
     /** 
      * Creates a piped writer that is not yet connected to a 
      * piped reader. It must be connected to a piped reader, 
      * either by the receiver or the sender, before being used. 
      * 
      * @see     java.io.PipedReader#connect(java.io.PipedWriter) 
      * @see     java.io.PipedWriter#connect(java.io.PipedReader) 
      */  
     public PipedWriter() {  
     }  
     //连接Reader，初始化in和out  
     public synchronized void connect(PipedReader snk) throws IOException {  
         if (snk == null) {  
             throw new NullPointerException();  
         } else if (sink != null || snk.connected) {  
             throw new IOException("Already connected");  
         } else if (snk.closedByReader || closed) {  
             throw new IOException("Pipe closed");  
         }  
   
         sink = snk;  
         snk.in = -1;  
         snk.out = 0;  
         snk.connected = true;  
     }  
     //写字符  
     public void write(int c)  throws IOException {  
         if (sink == null) {  
             throw new IOException("Pipe not connected");  
         }  
         sink.receive(c);  
     }  
     public void write(char cbuf[], int off, int len) throws IOException {  
         if (sink == null) {  
             throw new IOException("Pipe not connected");  
         } else if ((off | len | (off + len) | (cbuf.length - (off + len))) < 0) {  
             throw new IndexOutOfBoundsException();  
         }  
         sink.receive(cbuf, off, len);  
     }  
   
     /** 
      * Flushes this output stream and forces any buffered output characters 
      * to be written out. 
      * This will notify any readers that characters are waiting in the pipe. 
      * 
      * @exception  IOException  if the pipe is closed, or an I/O error occurs. 
      */  
     //刷新，强制缓存写出  
     public synchronized void flush() throws IOException {  
         if (sink != null) {  
             if (sink.closedByReader || closed) {  
                     throw new IOException("Pipe closed");  
             }  
             synchronized (sink) {  
                 sink.notifyAll();  
             }  
         }  
     }  
   
     /** 
      * Closes this piped output stream and releases any system resources 
      * associated with this stream. This stream may no longer be used for 
      * writing characters. 
      * 
      * @exception  IOException  if an I/O error occurs. 
      */  
     public void close()  throws IOException {  
         closed = true;  
         if (sink != null) {  
             sink.receivedLast();  
         }  
     }  
 }  