多线程 通过管道进行线程间通信

通过管道进行线程间通信
    * 在Java语言中提供了各种各样的输入/输出流Stream，使我们能够狠方便地对数据进行操作，其中管道
        流式一种特殊的流，用于在不同线程间直接传输数据。一个线程发送数据到输出管道，另一个线程
        从输入管道中读数据。通过使用管道，实现不同线程间的通信。


    * 在java的JDK中提供了4个类来使线程间可以进行通信
        1. PipedInputStream和PipedOutputStream
        2. PipedReader和PipedWriter
1. 字节流
    * 举个栗子
            public class WriteData {
                public void writeMethod(PipedOutputStream out){
                    try{
                        System.out.println("write :");
                        for(int i=0;i<300;i++){
                            String outData=""+(i+1);
                            out.write(outData.getBytes());
                            System.out.print(outData);
                        }
                        System.out.println();
                        out.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }


            public class ReadData {
                public void readMethod(PipedInputStream input){
                    try {
                        System.out.println("read :");
                        byte[] byteArray=new byte[20];
                        int readLength=input.read(byteArray);
                        while(readLength!=-1){
                            String newData=new String(byteArray,0,readLength);
                            System.out.print(newData);
                            readLength=input.read(byteArray);
                        }
                        System.out.println();
                        input.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }


            public class ThreadWrite extends Thread {
                private WriteData write;
                private PipedOutputStream out;
                public ThreadWrite(WriteData write,PipedOutputStream out){
                    super();
                    this.write=write;
                    this.out=out;
                }
                @Override
                public void run() {
                    write.writeMethod(out);
                }
            }


            public class ThreadRead extends Thread{
                private ReadData read;
                private PipedInputStream input;
                public ThreadRead(ReadData read,PipedInputStream input){
                    super();
                    this.read=read;
                    this.input=input;
                }
                @Override
                public void run() {
                    read.readMethod(input);
                }
            }


            public class Run {
                public static void main(String[] args){
                    try{
                        WriteData writeData=new WriteData();
                        ReadData readData=new ReadData();
                        PipedInputStream inputStream=new PipedInputStream();
                        PipedOutputStream outputStream=new PipedOutputStream();
                        outputStream.connect(inputStream);
                        ThreadRead threadRead=new ThreadRead(readData,inputStream);
                        threadRead.start();
                        Thread.sleep(2000);
                        ThreadWrite threadWrite=new ThreadWrite(writeData,outputStream);
                        threadWrite.start();
                    }catch (IOException e){
                        e.printStackTrace();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        注释：outputStream.connect(inputStream)的作用使两个Stream之间产生通信链接。
            在没有数据被写入是，int readLength=in.read(byteArray)处于阻塞状态，直到
            有数据被写入，才继续向下运行。
2. 字符流
    * 举个栗子
            public class WriteData {
                public void writeMethod(PipedWriter out){
                    try{
                        System.out.println("write :");
                        for(int i=0;i<300;i++){
                            String outData=""+(i+1);
                            out.write(outData);
                            System.out.print(outData);
                        }
                        System.out.println();
                        out.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }
            public class ReadData {
                public void readMethod(PipedReader input){
                    try{
                        System.out.println("read :");
                        char[] byteArray=new char[20];
                        int readLength=input.read(byteArray);
                        while(readLength!=-1){
                            String newData=new String(byteArray,0,readLength);
                            System.out.print(newData);
                            readLength=input.read(byteArray);
                        }
                        System.out.println();
                        input.close();
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }
            public class ThreadWrite extends Thread{
                private WriteData write;
                private PipedWriter out;
                public ThreadWrite(WriteData write,PipedWriter out){
                    super();
                    this.write=write;
                    this.out=out;
                }


                @Override
                public void run() {
                    write.writeMethod(out);
                }
            }
            public class ThreadRead extends Thread{
                private ReadData read;
                private PipedReader input;
                public ThreadRead(ReadData read,PipedReader input){
                    super();
                    this.read=read;
                    this.input=input;
                }


                @Override
                public void run() {
                    read.readMethod(input);
                }
            }
            public class Run {
                public static void main(String[] args){
                    try{
                        WriteData writeData=new WriteData();
                        ReadData readData=new ReadData();


                        PipedReader inputStream=new PipedReader();
                        PipedWriter outputStream=new PipedWriter();


                        outputStream.connect(inputStream);


                        ThreadRead threadRead=new ThreadRead(readData,inputStream);
                        threadRead.start();


                        Thread.sleep(2000);


                        ThreadWrite threadWrite=new ThreadWrite(writeData,outputStream);
                        threadWrite.start();
                    }catch (IOException e){
                        e.printStackTrace();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
            * 和字节流类似，就是输入输出会更加方便。