No.20 线程中的IO流

简介：

PipedInputStream/PipedReader ：管道输入流，主要在线程中使用 . 管道输入流是指一个通讯管道的接收端（Receiver）。
PipedOutputStream/PipedWriter ：管道输出流，指在一个通讯管道的发送端（Sender）
主要应用：一个线程通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

使用方法：

（1）在使用管道输出流和管道输入流时需要定义两个线程类（实现Runnable或继承Thread）
（2）在线程的发送端（Sender）内部，定义管道输出流：

public class Sender implements Runnable{

private PipedOutputStream pos;
//建立一个输出流对象通过发送端的构造函数传递
Sender(PipedOutputStream pos){
    this.pos = pos;
}

@Override
public void run() {
    //写入到输出流中
    for(int i = 75;i < 90 ;i++){
        try {
            pos.write(i);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    try {
        //写完记得关闭流对象
        pos.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

}
}

（3）在线程的接收端内部，定义管道输入流：

public class Receiver implements Runnable{

private PipedInputStream pis = null;
//建立构造函数传递一个管道输入流对象。
Receiver(PipedInputStream pis){
    this.pis = pis;
}
//实现线程部分代码：
@Override
public void run() {
    int len = 0;
    //读取管道内的数据
    try {
        while((len = pis.read()) != -1){
            
            System.out.println("Random: "  + (char)len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        pis.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
  }
}

（4）在主线程中需要完成：1）管道流的实例对象的生成；2）管道流的连接；3）实例化线程的接收端和发送端并把管道流传递进去；4）开启线程。

public class Test {
public static void main(String[] args) throws IOException {
    //分别创建输入流/输出流
    PipedOutputStream pos = new PipedOutputStream();
    PipedInputStream pis = new PipedInputStream();
    //链接输入输出流
    pos.connect(pis);
    //实例化发送端接收端
    Sender sender = new Sender(pos);
    Receiver receiver = new Receiver(pis);
    //创建并启动线程
    new Thread(sender).start();;
    new Thread(receiver).start();;

  } 
}

同样字符流应用在管道流中，下面就举一个列子利用管道流进行文件的复制：
接收端代码：线程的接收端-->管道输出端-->文件的输入端；

/**
 * 从管道输入流中读取数据，利用文件输出流写到文件中
 */
public class Receiver implements Runnable {
// 建立字符管道输入流，文件输出流，
private PipedReader pr = null;
private FileWriter fw;
private File file;

// 构造参数接受一个管道输入流，和一个File对象作为输出文件的地址
Receiver(PipedReader pr, File file) {
    this.pr = pr;
    this.file = file;
}

// 实现线程部分代码：
@Override
public void run() {
    try {
        fw = new FileWriter(file);
    } catch (IOException e) {
        System.out.println("文件不存在");
    }

    // 读取管道内的数据，并写入文件输出流中
    int data = 0;
    try {
        while ((data = pr.read()) != -1) {
            fw.write((char) data);
            fw.flush();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    //关闭流
    try {
        fw.close();
        pr.close();
    } catch (IOException e1) {
        e1.printStackTrace();
    }

  }
}

发送端代码：线程的发送端-->管道输入端-->文件的输出端；

/**
 * 从文件中读出数据进入文件输入流，并把文件输出流中的数据写入管道输出流中
 */
public class Sender implements Runnable {
private File file;
private FileReader fr;
private PipedWriter pw;

Sender(PipedWriter pw, File file) {
    this.pw = pw;
    this.file = file;
}

@Override
public void run() {
    try {
        fr = new FileReader(file);
        int data = 0;
        while ((data = fr.read()) != -1) {
            pw.write((char) data);
            pw.flush();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        fr.close();
        pw.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

  }
}

主线程代码：

public class Test {
public static void main(String[] args) throws IOException {
    File R_file = new File("d://text.txt");
    File S_file = new File("d://sc.txt");
    
    //分别创建输入流/输出流
    PipedReader pr = new PipedReader();
    PipedWriter pw = new PipedWriter();
    //链接输入输出流
    pr.connect(pw);
    //实例化发送端接收端
    Sender sender = new Sender(pw,R_file);
    Receiver receiver = new Receiver(pr,S_file);
    //创建并启动线程
    new Thread(sender).start();;
    new Thread(receiver).start();;

  } 
}

可以看到：IO操作在实际应用的过程中可能会因为需求嵌套使用。具体什么时候该选择什么流对象，在IO最后会有总结；