(每日持续更新）jdk api之PipedReader基础、应用、实战

博主18年的互联网软件开发经验，从一名程序员小白逐步成为了一名架构师，我想通过平台将经验分享给大家，因此博主每天会在各个大牛网站点赞量超高的博客等寻找该技术栈的资料结合自己的经验，晚上进行用心精简、整理、总结、定稿，每天都会整理到12点，为了就是能让大家能够真正了解该技术栈的真正原理，最终从程序员成为一名真正的架构师，写的不一定是全站做好的，但是是全站最用心的~。

以后我会推出一些列的文章，每天都会更新，每天进步一点点，发布顺序【java的api基础、应用、实战】->【java开源技术栈及源码分析】->【java开源技术栈整合】->【java低代码开发平台的建设】

关注【架构师成长之道】输入“java基础课程”，即可免费获得全套架构师全套课程

一、java.io

1.59 PipedReader

PipedReader 是 Java I/O 包中的一个类，用于从管道中读取字符数据。它通常与 PipedWriter 一起使用，用于线程之间的通信。

PipedReader 类介绍：

构造方法：

PipedReader(): 创建一个未连接到任何管道的管道输入流。
PipedReader(PipedWriter src): 创建一个连接到指定管道写入器的管道输入流。

方法摘要：

void connect(PipedWriter src) throws IOException: 将管道输入流连接到指定的管道写入器。
int read() throws IOException: 从管道读取一个字符。
int read(char[] cbuf, int off, int len) throws IOException: 将字符读入数组的某一部分。
void close() throws IOException: 关闭该流并释放与之关联的所有系统资源。

简单使用例子：

以下是一个简单的例子，演示了如何使用 PipedReader 从管道中读取字符数据：

javaCopy code
import java.io.*;

public class PipedReaderExample {

    public static void main(String[] args) {
        try {
            // 创建管道输入流和管道输出流
            PipedWriter pipedWriter = new PipedWriter();
            PipedReader pipedReader = new PipedReader();

            // 将管道输入流连接到管道输出流
            pipedReader.connect(pipedWriter);

            // 创建并启动写入线程
            Thread writerThread = new Thread(() -> {
                try {
                    String message = "Hello, Pipe!";
                    pipedWriter.write(message);
                    pipedWriter.close(); // 发送完毕后关闭输出流
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            writerThread.start();

            // 读取管道中的数据
            int data;
            while ((data = pipedReader.read()) != -1) {
                System.out.print((char) data);
            }

            // 关闭输入流
            pipedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们创建了一个 PipedReader 和一个 PipedWriter，然后将它们连接起来。写入线程向管道输出流写入数据，而主线程从管道输入流读取数据并将其打印到控制台上。

应用场景

PipedReader 主要用于实现线程之间的通信，通常与 PipedWriter 一起使用。以下是一些 PipedReader 的常见应用场景及相应的代码实现：

线程间通信：PipedReader 和 PipedWriter 可以用于在线程之间传输数据，例如在生产者-消费者模式中。

javaCopy code
import java.io.*;

public class ThreadCommunicationExample {

    public static void main(String[] args) {
        try {
            PipedWriter pipedWriter = new PipedWriter();
            PipedReader pipedReader = new PipedReader();
            pipedReader.connect(pipedWriter);

            // Producer Thread
            Thread producerThread = new Thread(() -> {
                try {
                    for (int i = 1; i <= 5; i++) {
                        pipedWriter.write(i);
                        Thread.sleep(1000);
                    }
                    pipedWriter.close();
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
            });

            // Consumer Thread
            Thread consumerThread = new Thread(() -> {
                try {
                    int data;
                    while ((data = pipedReader.read()) != -1) {
                        System.out.println("Received: " + data);
                    }
                    pipedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            producerThread.start();
            consumerThread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

数据处理管道：可以使用管道流来创建数据处理管道，其中一个线程写入数据到 PipedWriter，另一个线程从 PipedReader 中读取数据进行处理。

javaCopy code
import java.io.*;

public class DataProcessingPipeline {

    public static void main(String[] args) {
        try {
            PipedWriter pipedWriter = new PipedWriter();
            PipedReader pipedReader = new PipedReader();
            pipedReader.connect(pipedWriter);

            // Producer Thread
            Thread producerThread = new Thread(() -> {
                try {
                    String data = "Data to be processed";
                    pipedWriter.write(data);
                    pipedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            // Consumer Thread
            Thread consumerThread = new Thread(() -> {
                try {
                    StringBuilder stringBuilder = new StringBuilder();
                    int data;
                    while ((data = pipedReader.read()) != -1) {
                        stringBuilder.append((char) data);
                    }
                    System.out.println("Processed Data: " + stringBuilder.toString());
                    pipedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            producerThread.start();
            consumerThread.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上是两个使用 PipedReader 的常见应用场景及相应的代码实现。这些例子展示了如何使用 PipedReader 和 PipedWriter 实现线程之间的数据传输。

职场例子

下面是一个项目实战例子，演示了如何使用 PipedReader 和 PipedWriter 实现一个简单的消息传递系统，其中包括一个服务器端和多个客户端，服务器接收来自客户端的消息并广播给所有客户端。

javaCopy code
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class SimpleChatServer {
    private static final int PORT = 8888;
    private static final List<PipedWriter> clientWriters = new ArrayList<>();

    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("Server started. Listening on port " + PORT);

            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("New client connected: " + clientSocket);

                // Create piped streams for communication with client
                PipedWriter clientWriter = new PipedWriter();
                PipedReader clientReader = new PipedReader(clientWriter);

                // Add client writer to list
                clientWriters.add(clientWriter);

                // Start thread to handle client communication
                Thread clientThread = new Thread(new ClientHandler(clientSocket, clientReader));
                clientThread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ClientHandler implements Runnable {
        private final Socket clientSocket;
        private final PipedReader clientReader;

        public ClientHandler(Socket clientSocket, PipedReader clientReader) {
            this.clientSocket = clientSocket;
            this.clientReader = clientReader;
        }

        @Override
        public void run() {
            try (BufferedReader reader = new BufferedReader(clientReader)) {
                String message;
                while ((message = reader.readLine()) != null) {
                    System.out.println("Received from client " + clientSocket + ": " + message);
                    broadcast(message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        private void broadcast(String message) {
            System.out.println("Broadcasting message: " + message);
            for (PipedWriter writer : clientWriters) {
                try {
                    writer.write(message + "\n");
                    writer.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

上述代码实现了一个简单的聊天服务器，它监听指定端口，等待客户端连接。一旦有客户端连接，服务器将为其创建一个独立的线程来处理通信。每个客户端都有一个专用的 PipedWriter 用于向服务器发送消息，而服务器端使用 PipedReader 从每个客户端读取消息。服务器接收到消息后，会将其广播给所有连接的客户端。

你可以编写一个相应的客户端来连接到这个服务器，并与其他客户端进行通信。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/425887.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！