【Java 基础篇】深入理解 Java 管道（Pipes）：从基础到高级

news2024/9/29 11:38:32

在这里插入图片描述

Java 管道（Pipes）是一种强大的工具，用于实现进程间通信（Inter-Process Communication，IPC）。在本文中，我们将深入探讨 Java 管道的各个方面，从基础概念到高级用法，旨在帮助初学者更好地理解和应用这一重要的编程工具。

1. 引言

在软件开发中，不同的应用程序通常需要协同工作以完成特定的任务。为了实现应用程序之间的协同工作，需要一种机制来实现进程间通信。Java 管道正是为此而设计的。

Java 管道允许一个 Java 进程中的线程与另一个 Java 进程中的线程进行通信。这种通信方式非常强大，可用于各种场景，例如数据传输、任务协作等。在接下来的内容中，我们将学习如何使用 Java 管道来满足不同的通信需求。

2. 什么是 Java 管道？

Java 管道是一种特殊的流，用于在线程之间传递数据。它通常由两个管道流组成：一个输入管道流和一个输出管道流。输入管道流用于从一个线程读取数据，而输出管道流用于将数据写入另一个线程。这两个管道流之间的数据传输是单向的，即数据只能从输入流传输到输出流。

3. 基础用法

让我们从 Java 管道的基础用法开始，以便理解其工作原理。

3.1 创建管道

要使用 Java 管道，首先需要创建一个管道。Java 提供了 PipedInputStream 和 PipedOutputStream 两个类来分别表示输入管道流和输出管道流。以下是如何创建这两种管道的示例代码：

PipedInputStream inputStream = new PipedInputStream();
PipedOutputStream outputStream = new PipedOutputStream();

3.2 连接管道

创建管道后，需要将输入管道流与输出管道流连接起来，以便数据可以从一个流传输到另一个流。连接可以使用 connect 方法来完成，如下所示：

inputStream.connect(outputStream);

3.3 数据传输

一旦管道连接成功，就可以在两个线程之间传输数据了。通常，一个线程使用输出管道流将数据写入管道，而另一个线程使用输入管道流来读取数据。

以下是一个简单的例子，展示了如何在两个线程之间传输数据：

// 线程1：向输出管道流写入数据
Thread thread1 = new Thread(() -> {
    try {
        String message = "Hello, Pipe!";
        outputStream.write(message.getBytes());
        outputStream.close();  // 关闭输出流
    } catch (IOException e) {
        e.printStackTrace();
    }
});

// 线程2：从输入管道流读取数据
Thread thread2 = new Thread(() -> {
    try {
        byte[] buffer = new byte[1024];
        int bytesRead = inputStream.read(buffer);
        String message = new String(buffer, 0, bytesRead);
        System.out.println("Received message: " + message);
        inputStream.close();  // 关闭输入流
    } catch (IOException e) {
        e.printStackTrace();
    }
});

// 启动线程
thread1.start();
thread2.start();

在上面的示例中，线程1向输出管道流写入了一条消息，而线程2从输入管道流读取了这条消息，并在控制台上打印出来。

4. 高级用法

除了基础用法外，Java 管道还支持一些高级用法，可以满足更复杂的通信需求。

4.1 管道缓冲区

默认情况下，Java 管道没有内置的缓冲区，这意味着数据会立即从输出管道流传输到输入管道流。如果需要使用缓冲区，可以使用 PipedOutputStream 的构造函数来指定缓冲区大小：

PipedOutputStream outputStream = new PipedOutputStream(new PipedInputStream(1024));  // 指定缓冲区大小为 1024 字节

4.2 线程安全

Java 管道是线程安全的，这意味着多个线程可以同时读取和写入管道而不会导致数据混乱或错误。这使得 Java 管道非常适合多线程环境下的数据传输。

4.3 阻塞和非阻塞模式

默认情况下，当没有数据可读时，从输入管道流读取数据的操作会阻塞当前线程，直到有数据可用。这种行为称为阻塞模式。如果需要非阻塞模式，可以使用 available 方法来检查是否有可用的数据：

if (inputStream.available() > 0) {
    // 有可用的数据，可以读取
}

4.4 管道的关闭

当不再需要管道时，应该及时关闭它以释放资源。可以使用 close 方法来关闭输入管道流和输出管道流。

inputStream.close();
outputStream.close();

5. 更多用法

5.1 管道的嵌套使用

Java管道可以进行嵌套，即一个管道的输出流可以连接到另一个管道的输入流，以构建更复杂的数据传输管道。这对于将多个处理步骤连接在一起非常有用。

以下是一个简单的嵌套管道的示例：

import java.io.*;

public class NestedPipeExample {
    public static void main(String[] args) {
        try {
            PipedOutputStream outputStream1 = new PipedOutputStream();
            PipedInputStream inputStream1 = new PipedInputStream(outputStream1);

            PipedOutputStream outputStream2 = new PipedOutputStream();
            PipedInputStream inputStream2 = new PipedInputStream(outputStream2);

            // 线程1：将数据写入第一个管道
            Thread thread1 = new Thread(() -> {
                try {
                    outputStream1.write("Data from Thread 1".getBytes());
                    outputStream1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            // 线程2：从第一个管道读取数据并写入第二个管道
            Thread thread2 = new Thread(() -> {
                try {
                    byte[] buffer = new byte[1024];
                    int bytesRead = inputStream1.read(buffer);
                    String data = new String(buffer, 0, bytesRead);
                    System.out.println("Thread 2 received: " + data);

                    outputStream2.write("Processed by Thread 2".getBytes());
                    outputStream2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            // 线程3：从第二个管道读取数据
            Thread thread3 = new Thread(() -> {
                try {
                    byte[] buffer = new byte[1024];
                    int bytesRead = inputStream2.read(buffer);
                    String data = new String(buffer, 0, bytesRead);
                    System.out.println("Thread 3 received: " + data);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            thread1.start();
            thread2.start();
            thread3.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5.2 使用缓冲流

Java管道可以与缓冲流一起使用，以提高数据传输的效率。可以使用BufferedInputStream和BufferedOutputStream来包装管道流，以减少实际的I/O操作。

以下是一个使用缓冲流的示例：

import java.io.*;

public class BufferedPipeExample {
    public static void main(String[] args) {
        try {
            PipedOutputStream outputStream = new PipedOutputStream();
            PipedInputStream inputStream = new PipedInputStream(outputStream);

            // 使用缓冲流包装管道流
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

            // 线程1：写入数据
            Thread thread1 = new Thread(() -> {
                try {
                    bufferedOutputStream.write("Data from Thread 1".getBytes());
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            // 线程2：读取数据
            Thread thread2 = new Thread(() -> {
                try {
                    byte[] buffer = new byte[1024];
                    int bytesRead = bufferedInputStream.read(buffer);
                    String data = new String(buffer, 0, bytesRead);
                    System.out.println("Thread 2 received: " + data);
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            thread1.start();
            thread2.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用缓冲流可以减少实际的I/O操作次数，提高性能。

5.3 管道的对象传输

Java管道可以用于传输对象而不仅仅是字节数据。这需要使用对象流（ObjectInputStream和ObjectOutputStream）来包装管道流。这对于在多个Java应用程序之间传输Java对象非常有用。

以下是一个传输Java对象的示例：

import java.io.*;

public class ObjectPipeExample {
    static class MyObject implements Serializable {
        private String name;

        public MyObject(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }

 public static void main(String[] args) {
        try {
            PipedOutputStream outputStream = new PipedOutputStream();
            PipedInputStream inputStream = new PipedInputStream(outputStream);

            // 使用对象流包装管道流
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);

            // 线程1：写入对象
            Thread thread1 = new Thread(() -> {
                try {
                    MyObject obj = new MyObject("Object from Thread 1");
                    objectOutputStream.writeObject(obj);
                    objectOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });

            // 线程2：读取对象
            Thread thread2 = new Thread(() -> {
                try {
                    MyObject obj = (MyObject) objectInputStream.readObject();
                    System.out.println("Thread 2 received: " + obj.getName());
                    objectInputStream.close();
                } catch (IOException | ClassNotFoundException e) {
                    e.printStackTrace();
                }
            });

            thread1.start();
            thread2.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个示例演示了如何在管道上传输自定义Java对象。

5.4 管道的异常处理

在Java中，管道的使用可能会涉及到异常处理。以下是一些常见的管道操作异常以及如何处理它们的示例：

import java.io.*;

public class PipeExceptionHandling {
    public static void main(String[] args) {
        try {
            PipedOutputStream outputStream = new PipedOutputStream();
            PipedInputStream inputStream = new PipedInputStream(outputStream);

            // 线程1：尝试写入数据到已关闭的管道
            Thread thread1 = new Thread(() -> {
                try {
                    outputStream.close(); // 关闭管道
                    outputStream.write("Data from Thread 1".getBytes()); // 尝试写入数据
                } catch (IOException e) {
                    System.out.println("Thread 1: " + e.getMessage());
                }
            });

            // 线程2：尝试从已关闭的管道读取数据
            Thread thread2 = new Thread(() -> {
                try {
                    outputStream.close(); // 关闭管道
                    int bytesRead = inputStream.read(); // 尝试读取数据
                    System.out.println("Thread 2 received: " + bytesRead);
                } catch (IOException e) {
                    System.out.println("Thread 2: " + e.getMessage());
                }
            });

            thread1.start();
            thread2.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个示例演示了当管道已关闭时，尝试对其进行写入或读取会引发IOException的情况。您可以使用异常处理来捕获并处理这些异常，以确保您的程序能够更加健壮。

5.5 管道的线程同步

在多线程环境中使用管道时，可能需要考虑线程同步的问题，以防止竞态条件和数据不一致性。您可以使用Java中的同步机制，如synchronized关键字或java.util.concurrent包中的工具来确保线程安全。

以下是一个使用synchronized关键字来同步管道访问的示例：

import java.io.*;

public class PipeThreadSync {
    public static void main(String[] args) {
        try {
            PipedOutputStream outputStream = new PipedOutputStream();
            PipedInputStream inputStream = new PipedInputStream(outputStream);

            // 线程1：写入数据
            Thread thread1 = new Thread(() -> {
                synchronized (outputStream) {
                    try {
                        outputStream.write("Data from Thread 1".getBytes());
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });

            // 线程2：读取数据
            Thread thread2 = new Thread(() -> {
                synchronized (inputStream) {
                    try {
                        byte[] buffer = new byte[1024];
                        int bytesRead = inputStream.read(buffer);
                        String data = new String(buffer, 0, bytesRead);
                        System.out.println("Thread 2 received: " + data);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });

            thread1.start();
            thread2.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这个示例中，通过对outputStream和inputStream对象进行synchronized同步，确保了线程安全的写入和读取操作。

通过合理的异常处理和线程同步，可以确保在使用管道时程序能够稳定可靠地运行。

6. 管道的性能考虑

在使用管道时，还需要考虑性能方面的问题。以下是一些关于管道性能的注意事项：

  • 缓冲大小： 管道的性能受到缓冲区大小的影响。通常，较大的缓冲区可以提高吞吐量，但可能会增加内存消耗。可以根据具体需求调整缓冲区大小。

  • 线程数： 如果有多个生产者和消费者线程使用同一个管道，要考虑线程调度和竞争的影响。合理控制线程数，避免过多的线程竞争管道资源。

  • 流量控制： 当生产者产生数据速度快于消费者处理的速度时，可能会导致管道缓冲区溢出。可以通过流量控制机制，如限制生产者的写入速度或消费者的读取速度来解决这个问题。

  • 异常处理开销： 在使用管道时，异常处理可能会引入一些性能开销。因此，合理处理异常并避免不必要的异常抛出可以提高性能。

  • 多线程同步： 如前所述，多线程环境中需要考虑线程同步的性能开销。在高并发场景下，过多的同步操作可能会导致性能下降。

  • 关闭管道： 在不再需要管道时，及时关闭它以释放资源。未关闭的管道可能会导致资源泄漏和性能下降。

综上所述，管道的性能需要根据具体的使用场景进行合理的优化和控制。了解这些性能方面的注意事项可以帮助您更好地设计和使用管道，以满足应用程序的性能需求。

7. 管道的应用场景

管道在Java中有许多应用场景，以下是一些常见的示例：

  • 线程间通信： 管道可用于在线程之间传递数据，允许一个线程生成数据，另一个线程消费数据。

  • 进程间通信： 管道也可用于不同进程之间的通信。通过PipedOutputStream和PipedInputStream可以实现进程间的数据交换。

  • 日志处理： 管道可用于将日志数据从一个应用程序传输到另一个应用程序或存储位置。

  • 数据处理： 管道可用于数据处理流水线，其中一个阶段的输出作为下一个阶段的输入。

  • 网络编程： 在网络编程中，管道可以用于处理数据流，例如在服务器和客户端之间传递数据。

  • 文件处理： 管道可用于处理文件，例如在读取和写入文件之间建立数据流通道。

  • 安全性： 管道还可用于实现数据的加密和解密，以确保通信的安全性。

总之，管道是Java中用于数据传输和通信的强大工具，可以在各种应用场景中发挥作用。通过深入了解管道的工作原理、异常处理、性能考虑和应用场景，您可以更好地利用它们来满足应用程序的需求。

7. 结语

通过本文的介绍，我们深入了解了 Java 管道的基础概念和高级用法。Java 管道是一种强大的工具，可用于实现进程间通信，线程间数据传输等多种应用场景。希望本文能够帮助您更好地理解和应用 Java 管道，以满足不同的编程需求。感谢阅读！

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

linux-crontab每分钟定时执行/定时任务调度

linux-crontab每分钟定时执行/定时任务调度

文章目录 一、前言二、crontab概述2.1、crontab命令简介2.2、linux定时任务分类 三、安装crontab四、crontab使用4.1、crontab语法4.2、定时任务设置4.3、定时任务格式4.4 crontab表达式在线验证 五、实例六、定时任务的日志 一、前言 本文讲解linux上如何调用定时任务&#x…
阅读更多...
以太网ARP测试实验

以太网ARP测试实验

1.1 ARP测试整体框架 当上位机发送ARP请求时，FPGA返回ARP应答数据；当按下FPGA的触摸按键时，FPGA发送ARP请求，上位机返回ARP应答数据。 PLL时钟对eth_rxc的输入时钟进行相位调整；GMII TO RGMI 模块负责将双沿(DDR)数据和…
阅读更多...
树莓派安装mariadb

树莓派安装mariadb

mariadb与mysql十分类似，他们的使用方法类似，默认端口也都是3306 文章参考 树莓派mysql安装配置 – 蒋智昊的博客 目录 1 树莓派系统情况 2 安装mariadb 3 启动数据库 4 设置数据库自启动 5 进入数据库 1 树莓派系统情况 用的是树莓派4&…
阅读更多...
Linux性能调优 —— 内存篇

Linux性能调优 —— 内存篇

Linux性能调优 —— 内存篇 Linux内存的工作原理 内存映射的概念 虚存空间分布 内存分配与回收 分配 回收 内存查看与分析 查看内存使用情况 命令：free 命令：vmstat 命令：top 分析单个进程 命令：ps -p Linux内存的工作原理…
阅读更多...
把api_key 设置成win10系统变量然后python调用

把api_key 设置成win10系统变量然后python调用

1 设置环境变量存储秘钥 将API密钥存储在环境变量中，而不是直接写在代码中，可以降低泄露密钥的风险。 新建系统变量： 变量名：OPENAI_API_KEY 变量值：OpenAI API秘钥(上一步复制的那个key) 2获取值 import openai i…
阅读更多...
torch.cuda.is_available() 在有的项目中返回True有的返回Flase

torch.cuda.is_available() 在有的项目中返回True有的返回Flase

问题描述，刚下了一个项目，不能用CUDA 同一个环境不同项目中 torch.cuda.is_available() 返回值不同 问题来源： 这里的运行配置有问题 选择编辑配置并修改对应的解释器 查看 和 是否对应。 import torch print(torch.__version__) prin…
阅读更多...
iOS蓝牙 Connection Parameters 关键参数说明

iOS蓝牙 Connection Parameters 关键参数说明

1. 先贴苹果文档 《 Accessory Design Guidelines for Apple Devices 》 2. 几个关键词 connection Event Interval 事件间隔，为1.25ms的倍数。可以简单理解为,是两个连接着的蓝牙设备发送“心跳包”的时间间隔； 范围是 6 ~ 3200，即 7.5…
阅读更多...
运算符超详细讲解（系统性学习day5）

运算符超详细讲解（系统性学习day5）

目录 前言 一、运算符的概念与分类 二、算术运算符 三、关系运算符 四、逻辑运算符 五、赋值运算符 六、运算符的优先级 总结 前言 本篇文章是对运算符的具体讲解。 一、运算符的概念与分类 概念： 运算符就是一种告诉编译器执行特定的数学或逻辑操作的符…
阅读更多...
HarmonyOS开发：解决DevEco Studio低版本导入高版本项目运行失败问题

HarmonyOS开发：解决DevEco Studio低版本导入高版本项目运行失败问题

前言 基于DevEco Studio 4.0 Beta2，hvigorVersion为3.0.2，开发了一个项目，上传到了远程仓库，当同事下载后，却始终无法运行，频繁报错，由于API都是使用的9，第一感觉就是开发环境不同&a…
阅读更多...
【LeetCode-简单题KMP】232. 用栈实现队列

【LeetCode-简单题KMP】232. 用栈实现队列

文章目录 题目方法一：用输入栈和输出栈模拟队列 题目 方法一：用输入栈和输出栈模拟队列 只有输出栈为空的时候才能将输入栈的元素补充到输出栈，否则输出栈不为空，如果再从输入栈往输出栈填充元素，就会弄乱队列的先进先…
阅读更多...
Zotero的下载与使用

Zotero的下载与使用

Zotero的下载与使用 一、Zotero的下载二、Zotero的使用1、导入文献（1）直接拖入（2）在线导入 2、wps插入文献参考3、联动sci hub 实现英文文献一键批量下载 一、Zotero的下载 下载官网：https://www.zotero.org/ 下载地址…
阅读更多...
关于feign调用之间boolean类型的序列化问题

关于feign调用之间boolean类型的序列化问题

报错内容是这样的：这是controller层 这是feign调用层： 调试出错1： 调试出错2： 解决办法：
阅读更多...
Pytorch史上最全torch全版本离线文件下载地址大全（9月最新）

Pytorch史上最全torch全版本离线文件下载地址大全（9月最新）

以下为pytorch官网的全版本torch文件离线下载地址 torch全版本whl文件离线下载大全https://download.pytorch.org/whl/torch/其中的文件版本信息如下所示（部分版本信息，根据需要仔细寻找进行下载）：
阅读更多...
STM32F4X UCOSIII 消息队列

STM32F4X UCOSIII 消息队列

STM32F4X UCOSIII 消息队列 消息队列消息队列的作用消息队列工作机制消息队列创建消息发送消息发送模式FIFO(先进先出)LIFO(后进先出) 消息接收消息队列删除消息队列常用函数消息队列创建函数消息队列发送函数消息队列接收函数消息队列删除函数 UCOSIII 消息队列例程 消息队列 …
阅读更多...
Foxit PDF SDK Windows 9.1 Crack

Foxit PDF SDK Windows 9.1 Crack

Foxit PDF SDK 变更日志 Windows/Linux/Mac 2023 年 8 月 新功能/增强功能 在开始签名之前设置外观。支持使用共享字典添加签名。允许在调用 Signature::StartSign() 之前增量保存文档。在签名前修改现有未签名分页印章签名的外观。支持使用共享字典添加分页签名。忽略全角…
阅读更多...
【c语言】指针和数组笔试题

【c语言】指针和数组笔试题

1.指针和数组笔试题解析 一维数组 int a[] { 1,2,3,4 };printf("%d\n", sizeof(a));//a单独放在sizeof内表示求整个数组的字节-----16printf("%d\n", sizeof(a 0));//a不是单独放在sizeof内部，表明是首元素的地址，地址占4/8个字节…
阅读更多...
五个很实用的IDEA使用技巧

五个很实用的IDEA使用技巧

日常开发中，相信广大 Java 开发者都使用过 IntelliJ IDEA 作为开发工具，IntelliJ IDEA 是一款优秀的 Java 集成开发环境，它提供了许多强大的功能和快捷键，可以帮助开发者提高编码效率和质量。除了一些常见的技巧，如自动…
阅读更多...
[篇五章五]-如何禁用 Windows Defender-我的创作纪念日

[篇五章五]-如何禁用 Windows Defender-我的创作纪念日

################################################## 目录 禁用掉烦人的 Windows Defender 在本地组策略编辑器中禁用 Windows Defende 关闭 Microsoft Defender 防病毒 禁止 Defender 开机自动运行 重新激活 Windows Defender #######################################…
阅读更多...
字符串函数和内存函数详解（2）

字符串函数和内存函数详解（2）

🐵本文会将会对剩余的字符串库函数和内存函数进行讲解 1.strstr📚 1.1函数用法✏️ strstr函数原型： strstr用于在字符串中找子串，strstr会返回str1中出现str2的起始地址，如果在str1中没有找到str2，则返回…
阅读更多...
FreeRTOS移植以及核心功能

FreeRTOS移植以及核心功能

文章目录 freertos和ucos区别，优缺点比较移植步骤核心功能内存管理（5种内存管理策略）FreeRTOS任务调度算法有三种时间管理通信管理 栈管理 freertos和ucos区别，优缺点比较 FreeRTOS（Free Real-Time Operating System&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023