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

小鱼儿 2022-06-10 13:26 234阅读 0赞

通过管道进行线程间通信  
    \* 在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();  
                    \}  
                \}  
            \}  
            \* 和字节流类似，就是输入输出会更加方便。