举例讲解Java中Piped管道输入输出流的线程通信控制

讲解Java中Piped管道输入输出流的线程通信控制的攻略如下：

什么是Piped管道输入输出流

Java中的Piped输入输出流是一种基于管道（pipe）的流方式。管道是一种常见的进程间通信（IPC）的方式。Piped输入输出流提供了一个可以连接线程的管道，其中一个线程通过写入实现输出流的数据传递，而另一个线程通过读取实现输入流的数据读取。

Piped的使用方法

使用Piped管道输入输出流可以分为两部分：创建管道和写入/读取数据。下面将分别进行讲解。

创建管道

Piped管道输入输出流需要通过PipedInputStream和PipedOutputStream来创建。我们可以在创建PipedInputStream和PipedOutputStream时相互绑定，这是通过PipedInputStream的connect()方法和PipedOutputStream的connect()方法来实现的。例如：

PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream();
input.connect(output);

在上述代码中，创建了一个输入流input和输出流output，然后通过input.connect(output)来建立连接，此时input和output就形成了一个管道。

写入/读取数据

接下来演示如何进行写入和读取数据的操作。我们在一个线程中往PipedOutputStream中写入数据，然后在另一个线程中从PipedInputStream中读取数据。

public class PipeDemo {

    public static void main(String[] args) throws IOException, InterruptedException {
        PipedInputStream input = new PipedInputStream();
        PipedOutputStream output = new PipedOutputStream();
        input.connect(output);
        new Thread(new Writer(output)).start();
        new Thread(new Reader(input)).start();
    }

    static class Writer implements Runnable {
        private PipedOutputStream output;

        public Writer(PipedOutputStream output) {
            this.output = output;
        }

        @Override
        public void run() {
            try {
                for (int i = 0; i < 5; i++) {
                    output.write(("Hello, " + i + "\n").getBytes());
                    Thread.sleep(1000);
                }
                output.close();
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class Reader implements Runnable {
        private PipedInputStream input;

        public Reader(PipedInputStream input) {
            this.input = input;
        }

        @Override
        public void run() {
            try {
                BufferedReader reader = new BufferedReader(new InputStreamReader(input));
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

上面的代码其中有两个内部类Writer和Reader，分别代表着写入数据和读取数据两个线程。在Writer线程中，通过调用output.write()方法向管道中写入数据，这些数据会被Reader线程从管道中读取出来。Reader线程在创建缓冲字符输入流BufferedReader后，依次读取从管道中传递过来的数据，直到读取到的line为null，说明数据读取完毕。

我们将这段代码运行，可以看到输出结果如下：

Hello, 0
Hello, 1
Hello, 2
Hello, 3
Hello, 4

可以看到，Reader线程成功从管道中读取出Writer线程写入的数据，实现了线程之间的通信控制。

多线程情况下的使用

上面的示例只是演示了单个线程向管道中写入数据，另一个线程从管道中读取数据的情况。实际中，可能会有多个线程同时向管道中写入数据，或者从管道中读取数据，这种情况下的处理方式是创建多个PipedInputStream和PipedOutputStream对象，并在它们之间进行连接。

例如，我们在下面的示例中创建了两个写入线程和一个读取线程，它们都共用同一个输入流和输出流，实现了多个线程之间的通信。

public class MultiThreadPipeDemo {

    public static void main(String[] args) throws InterruptedException {
        PipedInputStream input = new PipedInputStream();
        PipedOutputStream output = new PipedOutputStream();
        input.connect(output);

        new Thread(new Writer(output, "Thread A")).start();
        new Thread(new Writer(output, "Thread B")).start();
        new Thread(new Reader(input)).start();
    }

    static class Writer implements Runnable {
        private PipedOutputStream output;
        private String name;

        public Writer(PipedOutputStream output, String name) {
            this.output = output;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                for (int i = 1; i <= 5; i++) {
                    output.write((name + ": " + i + "\n").getBytes());
                    Thread.sleep(1000);
                }
                output.close();
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class Reader implements Runnable {
        private PipedInputStream input;

        public Reader(PipedInputStream input) {
            this.input = input;
        }

        @Override
        public void run() {
            try {
                BufferedReader reader = new BufferedReader(new InputStreamReader(input));
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

上述代码中的Writer线程向同一个输出管道中写入数据，在管道中首先是线程A向管道中写入数据，然后是线程B，两个线程交替写入数据。在Reader线程中，通过缓冲字符输入流BufferedReader依次读取从管道中传递过来的数据，并输出到控制台。