管道之间的数据通信

 package pc;
 //PipedStreamTest.java //启动类
 import java.io.*; 
  public class PipedStreamTest
  {
        public static void main(String[] args) throws Exception 
        {
            Sender t1 = new Sender(); //创建发送者对象;
            Receiver t2 = new Receiver(); //创建接收者对象;
            PipedOutputStream out = t1.getOutputStream();
            PipedInputStream in = t2.getInputStream();
            out.connect(in); //用于连接到PipedInputStream上,与in.connect(out)等价,connect方法有异常出现的可能
            t1.start(); //启动线程
            t2.start(); //启动线程
        }
}

 

package pc;
import java.io.*;
//Receiver.java //接收者，也是一个线程类
public class Receiver extends Thread
{
    private PipedInputStream in = new PipedInputStream(); //接受者是要读取外面的数据，所以接受者内部创建PipedInputStream对象用于读取外面的数据
    public PipedInputStream getInputStream()
    {
    	//返回管道输入流对象
    	return in;
    }
//这是一个线程类，所以它应该覆盖Thread的run方法,run方法在线程类启动时自动运行
    public void run()
    { 
       //这里的run方法用于接收数据 
        byte[] buf = new byte[1024]; //字节数组
        try
        { 
        	//read和close方法都可能有异常出现
            int len = in.read(buf); //读取数据，len表示实际读取到的内容（长度）
            String str=new String(buf,0,len);
            System.out.println("下面的信息来自发送者:\n" +str);
            in.close();
        }
        catch(Exception e)
        {
        	e.printStackTrace();
        }
    }
}

 

    package pc;
    import java.io.*;
    public class Sender extends Thread
    { 
    	//表明是个线程类
        private PipedOutputStream out = new PipedOutputStream(); //发送者是要向外面写数据，所以发送者内部创建PipedOutputStream对象用于向外写数据
        public PipedOutputStream getOutputStream()
        { 
        	//返回管道输出流对象
        	return out;
        }
        //这是一个线程类，所以它应该覆盖Thread的run方法,run方法在线程类启动时自动运行
        public void run()
        { 
           //这里的run方法用于向PipedOutputStream中写入一串数据
            String strInfo = new String("hello,receiver!");
            try
            { 
            	//write和close方法都可能有异常出现
                out.write(strInfo.getBytes());
                out.close();
            }
            catch(Exception e)
            {
            	e.printStackTrace();
            }
        }
 }
    

 

package pc;

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

public class Test
{
	public static void main(String[] args)
	{
		//创建两个管道流
		PipedInputStream pin=new PipedInputStream();
		PipedOutputStream pout=new PipedOutputStream();
		try
		{
			pin.connect(pout);//pin的数据时从pout来
		} 
		catch (IOException e)
		{
			
			e.printStackTrace();
		}
		//创建两个线程
		Thread t1=new Sender(pout);
		Thread t2=new Receiver(pin);
		t1.start();
		t2.start();
	}
}
class Sender extends Thread
{
	private DataOutputStream dos;

	public Sender(PipedOutputStream p)
	{
		dos=new DataOutputStream(p);
	}
	public void run()
	{
		try
		{
			dos.writeUTF("HelloWorld");
			dos.close();
		} catch (IOException e)
		{
			
			e.printStackTrace();
		}
		
	}
}
class Receiver extends Thread
{
	private DataInputStream dis;
	public Receiver(PipedInputStream p)
	{
		dis=new DataInputStream(p);
	}
	public void run()
	{
		try
		{
			System.out.println(dis.readUTF());
			dis.close();
		} catch (IOException e)
		{
			
			e.printStackTrace();
		}
	}
}