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

通过管道进行线程间通信

    * 在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);

 
c20c
                      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();

                    }

                }

            }

            * 和字节流类似，就是输入输出会更加方便。