Java PipedWriter类的简介说明

PipedWriter是字符管道输出流
PipedWriter继承于Writer
PipedWriter可将当前线程的指定字符写入到与此线程对应的管道字符输入流中去、所以PipedReader、PipedWriter必须配套使用

PipedWriter类的构造函数

PipedWriter(PipedReader snk)    根据传入的PipedReader构造PipedWriter、并将PipedReader与此PipedWriter绑定  
PipedWriter()    创建一个PipedWriter、在使用之前必须与一个PipedReader绑定  

PipedWriter类的关键字

private PipedReader sink;   与此PipedWriter绑定的PipedReader  
private boolean closed = false;     标示此流是否关闭

PipedWriter类的方法

//Receiver
public class Receiver extends Thread { 
    // 管道输入流对象  
    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();  
        }  
    }  
}

//Sender
public class Sender extends Thread {  
    // 管道输出流对象。     
    private PipedWriter out = new PipedWriter();  
    // 获得“管道输出流”对象  
    public PipedWriter getWriter(){  
        return out;  
    }  
  
    @Override  
    public void run(){  
        writeShortMessage();  
        //writeLongMessage();  
    }  
  
    //向管道写入消息
    private void writeShortMessage() {  
        String strInfo = "java265.com 是最牛的网站" ;  
        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();  
        }  
    }  
}

//test
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();  
        }  
    }  
}
----运行以上代码，将输出以下信息-----
java265.com 是最牛的网站