javaIO-管道简单使用以及底层原理

ゝ一纸荒年。 2022-05-23 09:07 210阅读 0赞

## 前言 ##

今天来学习一下进程间的管道通信，管道有两种PipedInputStream，PipedOutputStream和PipedWriter和PipedReader

## 字节流 ##

package thread;
    
    import java.io.PipedOutputStream;
    
    public class DataWriter extends Thread{ 
        private PipedOutputStream out;
    
        public DataWriter(PipedOutputStream out) {
            this.out = out;
        }
    
        public void write() {
            try {
                String message = "123456";
                System.out.println("开始写数据了");
                out.write(message.getBytes());
                out.close();
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    
        @Override
        public void run() {
            write();
        }
    }

package thread;
    
    import java.io.PipedInputStream;
    import java.io.IOException;
    
    public class DataReader extends Thread{ 
    
        PipedInputStream input;
    
        public DataReader(PipedInputStream input) {
            this.input = input;
        }
    
        public void read() {
            try {
                System.out.println("开始读数据了");
                byte[] read = new byte[20];
                int num = input.read(read);
                System.out.println(new String(read, 0, num));
                input.close();
            } catch (IOException e) {
            }
        }
    
        @Override
        public void run() {
            read();
        }
    }

package thread;
    
    import java.io.PipedInputStream;
    import java.io.PipedOutputStream;
    
    public class Test { 
        public static void main(String[] args) {
    
            try {
                PipedInputStream input = new PipedInputStream();
                PipedOutputStream output = new PipedOutputStream();
    
                DataReader reader = new DataReader(input);
                DataWriter writer = new DataWriter(output);
    
                input.connect(output);
    
                reader.start();
                writer.start();
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }

## 字符流 ##

package thread;
    
    import java.io.IOException;
    import java.io.PipedReader;
    
    public class DataReader extends Thread{ 
    
        private PipedReader input;
    
        public DataReader(PipedReader input) {
            this.input = input;
        }
    
        public void read() {
            try {
                System.out.println("开始读数据了");
                char[] read = new char[2048];
                int num = input.read(read);
                System.out.println(new String(read, 0, num));
                input.close();
            } catch (IOException e) {
            }
        }
    
        @Override
        public void run() {
            read();
        }
    }

package thread;
    
    import java.io.PipedWriter;
    
    public class DataWriter extends Thread{ 
        private PipedWriter out;
    
        public DataWriter(PipedWriter out) {
            this.out = out;
        }
    
        public void write() {
            try {
                String message = "123456";
                System.out.println("开始写数据了");
                out.write(message);
                out.close();
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    
        @Override
        public void run() {
            write();
        }
    }

package thread;
    
    import java.io.PipedReader;
    import java.io.PipedWriter;
    
    public class Test {
        public static void main(String[] args) {
    
            try {
                PipedWriter out = new PipedWriter();
                PipedReader in = new PipedReader();
    
                DataReader reader = new DataReader(in);
                DataWriter writer = new DataWriter(out);
    
                in.connect(out);
    
                reader.start();
                writer.start();
    
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }

## 讲解，底层实现 ##

例子比较简单，关键是我们需要看看里面的一些原理，不用那么看源码，从我之前的经验来看看了也记不住。只需要看个大概就行了。

需要记住的是，输入和输出其实是共用一块数组存储空间，输出流的写操作用的其实是reader中的方法

管道中的写方法：

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);
        }

reader的缓冲区，缓冲区由reader掌控

char buffer[];

reader中的receive方法，用来写入数据

synchronized void receive(char c[], int off, int len)  throws IOException {
            while (--len >= 0) {
                receive(c[off++]);
            }
        }

知道这么多就足够了，细节部分不用深究。新手多学点实用的。