线程间管道通信（PipedInputStream,PipedOutputStream）

package ss;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

class WData{
public void WriteMethod(PipedOutputStream out) throws IOException{
try{
System.out.println("write:");
for(int i=0;i<10;i++){
String OutData=(i+1)+" ";
out.write(OutData.getBytes());
System.out.print(OutData);
}
}catch(IOException e){
e.printStackTrace();
}
System.out.println("W:");
out.close();
}
}
class RData{
public void ReadMethod(PipedInputStream input){
try{
System.out.println("read:");
byte[] byteArray=new byte[20];
int length=input.read(byteArray);
while(length!=-1){
String newData=new String(byteArray,0,length);
System.out.print(newData);
length=input.read(byteArray);
}
System.out.println("R:");
input.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
class ThreadA extends Thread{
WData w;
PipedOutputStream out;
public ThreadA(WData w,PipedOutputStream out){
this.w=w;
this.out=out;
}
public void run(){
super.run();
try {
w.WriteMethod(out);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class ThreadB extends Thread{
RData r;
PipedInputStream input;
public ThreadB(RData r,PipedInputStream input){
this.r=r;
this.input=input;
}
public void run(){
super.run();
r.ReadMethod(input);
}
}
public class Run {
public static void main(String[] args) throws InterruptedException, IOException {
WData W=new WData();
RData R=new RData();
PipedInputStream input=new PipedInputStream();
PipedOutputStream output=new PipedOutputStream();
output.connect(input);
ThreadB br=new ThreadB(R,input);
br.start();
Thread.sleep(5000);
ThreadA aw=new ThreadA(W,output);
aw.start();
}
}

//结果：

read:
write:
1 2 3 4 5 6 7 8 9 10 W:
1 2 3 4 5 6 7 8 9 10 R:

 

解释：当int length=input.read(byteArray);没有读取到数据的时候，这个线程一直处于阻塞状态，直到out.write(OutData.getBytes());写入数据后，才执行read数据线程。