Java高并发之线程通信(八)---管道

最新推荐文章于 2024-01-23 08:30:00 发布
最新推荐文章于 2024-01-23 08:30:00 发布
阅读量257 收藏 1
点赞数
分类专栏： 并发 文章标签： 并发

Java高并发之线程通信(管道)

Java管道原理：

广义上讲，管道就是一个用来在两个实体之间单项数据传输的导管。Java中的管道和linux中的管道是一样的，从本质上说，管道也是一种文件。

实际上原理很简单，如下图所示：

管道流特点：

1. 管道数据流向的单向的，数据只能从一个进程(线程)流向另一个进程(线程)，如果要进行双向通信，必须建立两个管道。

 

2. 管道的读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多数据。

 

3. 当管道输出流write()导致管道缓冲区变满时，管道的write()调用将默认的被阻塞，等待缓冲区的数据被读取。同样的读进程也可能工作得比写进程块。当所有当前进程数据被读取时，管道变空。当这种情况发生时，一个随后的read()调用将默认被阻塞，等待缓冲区数据，这解决了read()调用返回文件结束的问题。

 

4. 管道输出流或者管道输入流的提前关闭，不会影响到对端流。比如输出流提前结束，输入流不会产生异常；输入流的提前结束也不会影响到输出流。

管道使用实例：

注意：管道输出流输出结束后一定要关闭输出流，因为只有关闭输出流之后，对端输入流read()才能返回null，如果没有关闭输出流会发生什么呢？

当输出流使用后关闭时：

public class test {
    public static class Write extends Thread{
        public PipedOutputStream pos;
        Write(PipedOutputStream pos){
            this.pos = pos;
        }
        public void run(){
            PrintStream p = new PrintStream(pos);
            for(int i=1;i<10;i++){
                p.println("hello");
                p.flush();
            }
            p.close();
        }
    }
    
    public static class Read extends Thread{
        public PipedInputStream pis;
        public String line = "null";
        Read(PipedInputStream pis){
            this.pis = pis;
        }
        public void run(){
            BufferedReader r = new BufferedReader(new InputStreamReader(pis));
            try {
                while(line!=null){
                    line = r.readLine();
                    System.out.println(getName()+": "+line);
                }
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }    
 
    public static void main(String args[]) throws InterruptedException, IOException{
        //创建管道通信流
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos);
        new Write(pos).start();
        new Read(pis).start();
    }
}


输出结果如下:

可以看到最后管道输入流返回的是null。

 

当输出流使用完后不关闭时：

public class test {
    public static class Write extends Thread{
        public PipedOutputStream pos;
        Write(PipedOutputStream pos){
            this.pos = pos;
        }
        public void run(){
            PrintStream p = new PrintStream(pos);
            for(int i=1;i<10;i++){
                p.println("hello");
                p.flush();
            }
            //p.close();
        }
    }
    
    public static class Read extends Thread{
        public PipedInputStream pis;
        public String line = "null";
        Read(PipedInputStream pis){
            this.pis = pis;
        }
        public void run(){
            BufferedReader r = new BufferedReader(new InputStreamReader(pis));
            try {
                while(line!=null){
                    line = r.readLine();
                    System.out.println(getName()+": "+line);
                }
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }    
 
    public static void main(String args[]) throws InterruptedException, IOException{
        //创建管道通信流
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos);
        new Write(pos).start();
        new Read(pis).start();
    }
}


输出结果如下：

可以看到输入流没有返回null，而是返回一个异常：Write end dead。

所以当管道通信结束后一定要关闭管道输出流。输入流可以通过read()方法是否返回null来判断管道通信是否结束。


工程中的管道使用：

上述的管道通信的例子只是用于实验的，在实际工程中我们并不会这样使用管道，把管道的两端(即管道输出流和管道输入流)设置为全局可见的是不安全的，会造成管道泄漏的问题。

我们看下面的代码：


public class test {
    public static class Write extends Thread{
        public PipedOutputStream pos;
        Write(PipedOutputStream pos){
            this.pos = pos;
        }
        public void run(){
            PrintStream p = new PrintStream(pos);
            for(int i=1;i<1000;i++){
                p.println("hello");
                p.flush();
            }
            p.close();
        }
    }
    
    public static class Read extends Thread{
        public PipedInputStream pis;
        public String line = "null";
        Read(PipedInputStream pis){
            this.pis = pis;
        }
        public void run(){
            BufferedReader r = new BufferedReader(new InputStreamReader(pis));
            try {
                while(line!=null){
                    line = r.readLine();
                    System.out.println("read: "+line);
                }
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    public static class Other_Thread extends Thread{
        public PipedInputStream pis;
        public String line = "null";
        Other_Thread(PipedInputStream pis){
            this.pis = pis;
        }
        public void run(){
            BufferedReader r = new BufferedReader(new InputStreamReader(pis));
            try {
                while(line!=null){
                    line = r.readLine();
                    System.out.println("Other_Thread: "+line);
                }
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void main(String args[]) throws InterruptedException, IOException{
        //创建管道通信流
        PipedOutputStream pos = new PipedOutputStream();
        PipedInputStream pis = new PipedInputStream(pos);
        new Write(pos).start();
        new Read(pis).start();
        new Other_Thread(pis).start();
    }
}


这里我多创建了一个线程Other_Thread，用来模拟write线程和read线程正常通信的情况下，Other_Thread线程获取了全局的管道输入流，并运行，看看会发生什么吧。

运行结果：

这是运行结果的一个片段，但是已经可以说明问题了，write线程的管道数据被Other_Thread线程截取了，这样的设计会产生管道泄漏问题。

在工程中更科学的利用管道应该如下:

public class test {
    public static class Write extends Thread{
        public PipedOutputStream pos = null;
        
                //获取线程中的管道输出流
        public PipedOutputStream getPos(){
                        pos = new PipedOutputStream();
            return pos;
        }
        @Override
        public void run(){
            PrintStream p = new PrintStream(pos);
            for(int i=1;i<1000;i++){
                p.println("hello");
                p.flush();
            }
            p.close();
        }
    }
    
    public static class Read extends Thread{
        public PipedInputStream pis = null; 
        public String line = "null";
 
        //获得线程中的管道输入流
        public PipedInputStream getPis(){
                        pis = new PipedInputStream();
            return pis;
        }
        @Override
        public void run(){
            BufferedReader r = new BufferedReader(new InputStreamReader(pis));
            try {
                while(line!=null){
                    line = r.readLine();
                    System.out.println("read: "+line);
                }
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String args[]) throws InterruptedException, IOException{
        Write write = new Write();
        Read read = new Read();
        //连接两个线程的管道流
        write.getPos().connect(read.getPis());
        write.start();
        read.start();
    }
}

 


在实际工程中一个线程往往需要跟多个线程通信，比如，write线程与read线程通信结束后，还需要write线程与其他线程通信，该怎么办呢？请看如下代码：

public class test {
    public static class Write extends Thread{
        public PipedOutputStream pos = null;
        
        //获取线程中的管道输出流
        public PipedOutputStream getPos(){
            pos = new PipedOutputStream();
            return pos;
        }
        //把数据通过管道输出流发送出去
        public void SentData(){
            PrintStream p = new PrintStream(pos);
            for(int i=1;i<10;i++){
                p.println("hello");
                p.flush();
            }
            p.close();
        }
        @Override
        public void run(){
            while(true);         //模拟耗时工作
        }
    }
    
    public static class Read extends Thread{
        public PipedInputStream pis = null; 
        public String line = "null";
        
        //获得线程中的管道输入流
        public PipedInputStream getPis(){
            pis = new PipedInputStream();
            return pis;
        }
        //利用管道输入流接收管道数据
        public void ReceiveData(){
            BufferedReader r = new BufferedReader(new InputStreamReader(pis));
            try {
                while(line!=null){
                    line = r.readLine();
                    System.out.println("read: "+line);
                }
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void run(){
            while(true);        //模拟耗时工作
        }
    }
    
    public static class Other_Thread extends Thread{
        public PipedInputStream pis = null; 
        public String line = "null";
        
        //获得线程中的管道输入流
        public PipedInputStream getPis(){
            pis = new PipedInputStream();
            return pis;
        }
        //利用管道输入流接收管道数据
        public void ReceiveData(){
            BufferedReader r = new BufferedReader(new InputStreamReader(pis));
            try {
                while(line!=null){
                    line = r.readLine();
                    System.out.println("Other thread: "+line);
                }
                r.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void run(){
            while(true);   //模拟耗时操作
        }
    }
    public static void main(String args[]) throws InterruptedException, IOException{
        Write write = new Write();
        Read read = new Read();
        Other_Thread other = new Other_Thread();
        //连接两个线程的管道流 ---read和write线程
        write.getPos().connect(read.getPis());
        write.start();
        read.start();
        other.start();
        write.SentData();
        read.ReceiveData();
        Thread.sleep(2000);
        //重新连接两个线程的管道流 ---Other_Thread和write线程
        write.getPos().connect(other.getPis());
        write.SentData();
        other.ReceiveData();
    }
}


运行结果：

这只是输出的一个片段，但是已经能够说明问题了。


--------------------- 
 

和尚不洗碗
关注
专栏目录
JAVA的多线程与高并发
GD_YuZhe的博客
07-22 562
概念 进程 进程指正在运行的程序，进程拥有一个完整的、私有的基本运行资源集合。通常，每个进程都有自己的内存空间。 进程往往被看作是程序或应用的代名词，然而，用户看到的一个单独的应用程序实际上可能是一组相互 协作的进程集合。 为了便于进程之间的通信，大多数操作系统都支持进程间通信(IPC)，如pipes 和sockets。IPC不仅支持同一系统上的通信，也支持不同的系统。IPC通信方式包括管道(包括无名管道和命名管道)、消息队列、信号量、共享存储、Socket、Streams等方式，其中 Socket
Java管道流实现线程间通信过程解析
08-19
在实际开发中，Java管道流常用于实现高并发、实时数据交换的场景，例如在线聊天系统、实时数据分析系统等。 在Java语言中，PipedInputStream和PipedOutputStream是字节流，用于传送字节数据，而PipedReader和...
java线程 管道_java:管道流（线程间管道流）
weixin_35455673的博客
02-12 112
class Send implements Runnable{PipedOutputStream pos = null;public Send(){this.pos = new PipedOutputStream();}public PipedOutputStream getPipedOutputStream(){return this.pos;}@Overridepublic void run(...
java线程 管道_java多线程之管道流
weixin_39636245的博客
02-12 77
public classWriteData {public voidwriteMethod(PipedWriter out){try{System.out.println("write:");for (int i = 0; i < 100; i++) {String data=""+i;out.write(data);System.out.print(data);}System.out.pr...
Java线程间通信--管道
ljz2016的博客
11-12 352
Java提供了多种输入输出流用于对数据进行操作，其中管道流pipeStream是一种特殊的流，用于在不同线程间直接传送数据。 pis.read的时候，如果管道内没有数据，会阻塞。 public class PipeStreamMain { public static void main(String[] args) throws IOException { PipedInp...
java线程 管道_Java 线程间通讯（管道流方式）
weixin_35875219的博客
02-12 161
一、管道流是JAVA中线程通讯的常用方式之一，基本流程如下：1)创建管道输出流PipedOutputStream pos和管道输入流PipedInputStream pis2)将pos和pis匹配，pos.connect(pis);3)将pos赋给信息输入线程，pis赋给信息获取线程，就可以实现线程间的通讯了packagewyf;importjava.io.IOException;importja...
java多线程tcpsocketserver源码-netty-learning:网络学习
06-05
java多线程tcp socket server源码@Netty 笔记 1. 内蒂 网络应用框架 特征 设计 支持多种传输类型 事件模型 高度可定制的线程模型 表现 高吞吐量，低延迟 更少的资源消耗 最小化内存拷贝 安全SSL/TLS 支持 建筑学 核 ...
Java 高并发八：NIO和AIO详解
09-01
【Java 高并发八：NIO和AIO详解】 NIO（New Input/Output），从Java 1.4版本开始引入，是对传统IO模型的一种改进。传统的IO模型基于流（Stream），而NIO则基于块（Block）进行数据传输，提高了处理大量数据时的效率...
java高并发编程源码.zip
11-06
Java高并发编程是Java开发中的重要领域，它涉及到如何在多线程环境下高效地管理和调度系统资源，以实现系统的高性能和可伸缩性。在这个"java高并发编程源码.zip"压缩包中，可能包含了一些关于Java并发编程的示例代码...
Java多线程管道通信
m0_37148920的博客
04-09 271
java多线程场景，线程与线程之间需要通信协作，管道就是其中之一；例如场景：按照用户搜索条件查询数据，并将数据下载到用户本地，那系统通常的做法就是按照用户检索条件查询出结果集，将结果集生成excel表，在将excel表上传到ftp或者oss云盘之类的地方，最后将下载连接发送给用户，最后用户点击链接进行下载，那么使用管道就减少了数据生成到本地，在上传到云盘的工作，直接生成到用户下载，提高用户体验和效率。
java多线程之管道流
weixin_30723433的博客
07-11 93
java语言中提供了各种各样的流供我们操纵数据，其中管道流（pipeStream）是一种特殊的流，用于在不同线程间直接传送数据。 一个线程发送数据到输出管道，另一个线程从输入管道读取数据，通过使用管道，实现不同线程间的通信，而无需借助于临时文件之类的东西。 在java jdk中提供了4个类用于线程间通信,分别是字节流和字符流，应用起来大体相同： 1.PipedInputStream和Pipe...
java 线程 管道_Java 中利用管道实现线程间的通讯
weixin_42518874的博客
02-21 291
下载本文示例代码在Java 语言中，提供了各种各样的输入输出流(stream),使我们能够很方便的对数据进行操作，其中，管道(pipe)流是一种特殊的流，用于在不同线程(threads)间直接传送数据。一个线程发送数据到输出管道，另一个线程从输入管道中读数据。通过使用管道，实现不同线程间的通讯。无需求助于类似临时文件之类的东西。本文在简要介绍管道的基本概念后，将以一个具体的实例pipeapp加以详...
[Java并发编程]浅谈管道
最新发布
程序员三木的博客
01-23 400
Java管道是一种在多线程编程中用于线程间通信的机制。通过使用管道，我们可以简化线程间通信的实现，提高代码的可读性和可维护性。使用和可以方便地实现管道功能。在使用管道时，要注意线程之间的同步和关闭管道输入流和输出流的适时操作。
Java多线程-Pip管道
weixin_45203607的博客
05-09 608
管道的意思,就是向一个管子一样从一端到另一端, 只支持单方向的数据传输, 需要注意的不能在同一个线程使用管道否则会导致死锁的情况,发生和接收必须在不同线程, 通过使用管道，实现不同线程间的通信，而无需借助于临时文件之类的东西。免责声明：本文部分素材来源于网络，版权归原创者所有，如存在文章/图片/音视频等使用不当的情况，请随时私信联系我、以迅速采取适当措施，避免给双方造成不必要的经济损失。其分为两类：字节流和字符流，基本步骤为：线程A写入数据到输出流，线程B从输入流读取数据, ,从而实现线程通讯。
java 线程之间的管道通信
每天进步一点点 - MinCase
04-26 612
java 线程之间的管道通信：  import java.io.IOException; import java.io.PipedReader; import java.io.PipedWriter; import java.util.Random; import java.util.concurrent.ExecutorService; import java.util.concur
java线程 管道,使用Java在线程之间管道数据
weixin_29952235的博客
02-12 77
I am writing a multi-threaded application that mimics a movie theater. Each person involved is its own thread and concurrency must be done completely by semaphores. The only issue I am having is how...
高并发--卷3--线程间的通信
qq_25956141的博客
07-10 121
线程进行通信有很多办法，我们可以使用一个全局变量，让两个线程对该变量进行状态的监听，但是这种方法，需要用循环来进行监听，比较占用资源。如果看了前面的卷1-卷2，那么你可能也看到了，通过interrupt()和currentThread.isInterrupted()来真正停止一个线程，或者你也看到了，suspend()和resume()实现线程的阻塞和线程的继续运行，这些都是线程进行通信的例...
java多线程通信（管道通信）
gchichafengyun的专栏
07-15 1438
管道流类PipedInputStream类和PipedOutputStream类用于在应用程序中创建管道通信。一个PipedInputStream实例对象必须和PipedOutputStream实例对象进行连接而产生一个通信管道，PipedOutputsStream可以向管道中写入数据，PipedInputStream可以从管道中读取PipedOutputStream写入的数据，这两个类主要用来完
Java管道通信详解：PipedWriter/PipedReader多线程协作
Java中Piped管道输入输出流的线程通信控制是一种高级的并发机制，它利用PipedOutputStream和PipedInputStream这两个类来实现线程之间的数据交换。这两个类分别代表管道的输出端和输入端，它们之间通过内部的缓冲区...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值