（五）PipedInputStream与PipedOutputStream

最新推荐文章于 2025-05-14 19:13:02 发布
原创 最新推荐文章于 2025-05-14 19:13:02 发布 · 453 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细解析了PipedInputStream与PipedOutputStream的工作原理，包括如何实现进程内线程间通信，以及数据如何在缓存数组中流转。

PipedInputStream与PipedOutputStream需要配套使用，用于同一个进程之间不同线程的通信。
首先先看一下PipedOutputStream源码

//内部持有一个PipedInputStream的引用，通过connect()将两者绑定在一起,当然通过PipedInputStream.connect也可以进行绑定，效果都是一样的，后面可以看到。
private PipedInputStream sink;

 public PipedOutputStream(PipedInputStream snk)  throws IOException {
        connect(snk);
    }

      public PipedOutputStream() {
    }

       public synchronized void connect(PipedInputStream snk) throws IOException {
        if (snk == null) {
            throw new NullPointerException();
        } else if (sink != null || snk.connected) {
            throw new IOException("Already connected");
        }
        sink = snk;
        snk.in = -1;//缓存下标
        snk.out = 0;//未读下标
        snk.connected = true;
    }
//观察write()函数可以发现，写入的数据通过PipedInputStream.receive（）传到了PipedInputStream内部，自身并没有进行任何数据的缓存。
 public void write(int b)  throws IOException {
        if (sink == null) {
            throw new IOException("Pipe not connected");
        }
        sink.receive(b);
    }

       public void write(byte b[], int off, int len) throws IOException {
        if (sink == null) {
            throw new IOException("Pipe not connected");
        } else if (b == null) {
            throw new NullPointerException();
        } else if ((off < 0) || (off > b.length) || (len < 0) ||
                   ((off + len) > b.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        sink.receive(b, off, len);
    }

 //刷新函数也只是读线程激活。
 public synchronized void flush() throws IOException {
        if (sink != null) {
            synchronized (sink) {
                sink.notifyAll();
            }
        }
    }
   //关闭流也是通过持有输入流引用进行，receivedLast()函数主要是激活所有读线程开始读取。
    public void close()  throws IOException {
        if (sink != null) {
            sink.receivedLast();
        }
    }

PipedOutputStream的源码比较简单，重点还是要分析一下PipedInputStream源码

    boolean closedByWriter = false;//输出流是否关闭
    volatile boolean closedByReader = false;//输入流是否关闭
    boolean connected = false;//是否关联

    Thread readSide;//当前读线程
    Thread writeSide;//当前写线程
    //缓存区大小
    private static final int DEFAULT_PIPE_SIZE = 1024;
    protected static final int PIPE_SIZE = DEFAULT_PIPE_SIZE;

    //缓存数组
    protected byte buffer[];
    //存储下标
    protected int in = -1;
    //读取下标
    protected int out = 0;
    //当in == out表示缓存区所有数据都已读
//构造函数可以设置缓存区大小

 public PipedInputStream(PipedOutputStream src) throws IOException {
        this(src, DEFAULT_PIPE_SIZE);
    }   
    public PipedInputStream(PipedOutputStream src, int pipeSize)
            throws IOException {
         initPipe(pipeSize);
         connect(src);
    }

    public PipedInputStream() {
        initPipe(DEFAULT_PIPE_SIZE);
    }

    public PipedInputStream(int pipeSize) {
        initPipe(pipeSize);
    }

    private void initPipe(int pipeSize) {
         if (pipeSize <= 0) {
            throw new IllegalArgumentException("Pipe Size <= 0");
         }
         buffer = new byte[pipeSize];
    }

   //connect函数可以进行输入/输出流的绑定
   //最后调用的还是PipedOutputStream.connect()
    public void connect(PipedOutputStream src) throws IOException {
        src.connect(this);
    }
//当输出流输出数据时被调用，数据都过该函数存储到输入流中
//这两个函数只会被PipedOutputStream实例通过PipedInputStream引用进行调用。
 protected synchronized void receive(int b) throws IOException {
        checkStateForReceive();//检查状态,是否绑定啊是否被关闭啊
        writeSide = Thread.currentThread();
        if (in == out)//没有数据可以读取，需要进行线程阻塞等待数据
            awaitSpace();
        if (in < 0) {
            in = 0;
            out = 0;
        }
        buffer[in++] = (byte)(b & 0xFF);
        if (in >= buffer.length) {//循环数组
            in = 0;
        }
    }


    synchronized void receive(byte b[], int off, int len)  throws IOException {
        checkStateForReceive();
        writeSide = Thread.currentThread();
        int bytesToTransfer = len;
        //循环写入，直到结束
        while (bytesToTransfer > 0) {
            if (in == out)//等待数据写入
                awaitSpace();
            int nextTransferAmount = 0;
            //这一段用于计算可存储长度
            if (out < in) {//读取比写入慢
                nextTransferAmount = buffer.length - in;
            } else if (in < out) {
                if (in == -1) {//整个数组可存
                    in = out = 0;
                    nextTransferAmount = buffer.length - in;
                } else {//buffer[in]~buffer[out]之间的数据是读过的，buffer[out]-buffer[buffer.length-1]和buffer[0]~buffer[in]的数据是未读的
                    nextTransferAmount = out - in;
                }
            }
            //取最小
            if (nextTransferAmount > bytesToTransfer)
                nextTransferAmount = bytesToTransfer;

            assert(nextTransferAmount > 0);
            System.arraycopy(b, off, buffer, in, nextTransferAmount);
            bytesToTransfer -= nextTransferAmount;
            off += nextTransferAmount;
            in += nextTransferAmount;
            if (in >= buffer.length) {
                in = 0;
            }
        }
    }

  private void checkStateForReceive() throws IOException {
        if (!connected) {
            throw new IOException("Pipe not connected");
        } else if (closedByWriter || closedByReader) {
            throw new IOException("Pipe closed");
        } else if (readSide != null && !readSide.isAlive()) {
            throw new IOException("Read end dead");
        }
    }

    private void awaitSpace() throws IOException {
        while (in == out) {
            checkStateForReceive();

            /* full: kick any waiting readers */
            notifyAll();
            try {
                wait(1000);
            } catch (InterruptedException ex) {
                throw new java.io.InterruptedIOException();
            }
        }
    }

    synchronized void receivedLast() {
        closedByWriter = true;
        notifyAll();
    }
 public synchronized int read()  throws IOException {
        if (!connected) {
            throw new IOException("Pipe not connected");
        } else if (closedByReader) {
            throw new IOException("Pipe closed");
        } else if (writeSide != null && !writeSide.isAlive()
                   && !closedByWriter && (in < 0)) {
            throw new IOException("Write end dead");
        }

        readSide = Thread.currentThread();
        int trials = 2;
        while (in < 0) {
            if (closedByWriter) {
                /* closed by writer, return EOF */
                return -1;
            }
            if ((writeSide != null) && (!writeSide.isAlive()) && (--trials < 0)) {
                throw new IOException("Pipe broken");
            }
            /* might be a writer waiting */
            notifyAll();
            try {
                wait(1000);
            } catch (InterruptedException ex) {
                throw new java.io.InterruptedIOException();
            }
        }
        int ret = buffer[out++] & 0xFF;
        if (out >= buffer.length) {
            out = 0;
        }
        if (in == out) {
            /* now empty */
            in = -1;
        }

        return ret;
    }


    public synchronized int read(byte b[], int off, int len)  throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        /* possibly wait on the first character */
        int c = read();
        if (c < 0) {
            return -1;
        }
        b[off] = (byte) c;
        int rlen = 1;
        while ((in >= 0) && (len > 1)) {

            int available;

            if (in > out) {
                available = Math.min((buffer.length - out), (in - out));
            } else {
                available = buffer.length - out;
            }

            // A byte is read beforehand outside the loop
            if (available > (len - 1)) {
                available = len - 1;
            }
            System.arraycopy(buffer, out, b, off + rlen, available);
            out += available;
            rlen += available;
            len -= available;

            if (out >= buffer.length) {
                out = 0;
            }
            if (in == out) {
                /* now empty */
                in = -1;
            }
        }
        return rlen;
    }
总结
  1. 通过PipedOutputStream输出的数据直接写入到PipedInputStream的缓存数组中了。
  2. 当写线程写入数据时，发现没有空间写入时，激活所有读线程读取数据并阻塞自身线程，直到有空间写入或被读线程所通知。
  3. 当读线程读取数据，发现没有数据可读时，通知所有写线程写入数据并阻塞自身线程，直到有数据可读或被写线程通知。
Java8 I/O源码-PipedInputStream与PipedOutputStream
潘威威的博客
10-12 1596
PipedInputStream与PipedOutputStream分别为管道输入流和管道输出流。管道输入流通过连接到管道输出流实现了类似管道的功能，用于线程之间的通信。 通常，由某个线程向管道输出流中写入数据。根据管道的特性，这些数据会自动发送到与管道输出流对应的管道输入流中。这时其他线程就可以从管道输入流中读取数据，这样就实现了线程之间的通信。
PipedInputStream和PipedOutputStream
zhanggf的博客
01-12 1091
PipedInputStream类与PipedOutputStream类用于在应用程序中创建管道通信.一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道.PipedOutputStream可以向管道中写入数据,PipedIntputStream可以读取PipedOutputStream向管道中写入的数据.这两个类主要用来完成线
Java中的管道流 PipedOutputStream和PipedInputStream
weixin_30371469的博客
05-14 623
我们在学习IO流的时候可能会学字节流、字符流等，但是关于管道流的相信大部分视频或者教程都是一语带过，第一个是因为这个东西在实际开发中用的也不是很多，但是学习无止境，存在既有理。JDK中既然有个类那说明他并不是一无是处，只是我们目前还没有场景用到它，那说明我们说的还不够，知识点还不足以去驾驭它。 管道流其实是一个很有魅力的流，用法也很独特。他用来连接两个线程之间的通信...
Android学习笔记（五）
babyai996的博客
11-09 159
由于字节访问硬盘的次数非常平凡 所以对硬盘造成的伤害比较高 ，最好在内存建立一个小的空间 叫硬盘每次先填满这个空间在去访问硬盘，这个空间人们常用字节数组来建立 byte[] byte = new bute[1024]()原来如此,不过这只是说说而已,具体怎么实现的呢,爱刨根问底的我可不会轻易放过这些疑惑,于是看了一下SUN源码这两个类的实现,恕本人比较愚钝,把玩了大半天,才稍微参透其中一些奥妙,故将心得体会在此写上,供各位批判:)按照数据单位不同可以分为字节流和字符流（字节：一个字节是八位。
java文件io管道（PipedInputStream和PipedOutputStream）介绍及使用
weixin_42738587的博客
11-23 1744
简介 PipedOutputStream和PipedInputStream分别是管道输出流和管道输入流。它们的作用是让多线程可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedOutputStreamPipedInputStream配套使用。使用管道通信时，大致的流程是：在线程A中写入数据，这些数据会存储在PipedInputStream的缓冲区中；此时，线程B通过读取PipedInp...
Java IO流之PipedOutputStream和PipedInputStream分析
梦悠哉的博客
08-02 1373
  简介     PipedOutputStream和PipedInputStream分别是管道输出流和管道输入流,是字节流的一种。两者配合使用可以进行同一个进程不同线程之间的通信，管道输入流用于向管道中读取数据，管道输出流用于向管道中写入数据。通常管道输入流和管道输出流在不同的线程中，如果在同一个线程可能存在死锁的情况。     实现方式大致是，管道输出流与管道输出流进行关联，当一个线程向...
java 管道符,java.io源码解析（五）--管道字节流（PipedInputStream，PipedOutputStream）管道字符流（PipedReader，PipedWriter）...
weixin_31174671的博客
03-20 412
声明：本系列只供本人自学使用，勿喷。管道流一般用于线程间的通讯。大致流程：在线程A中向PipedOutputStream中写入数据，这些数据会自动的发送到与PipedOutputStream对应的PipedInputStream中，进而存储在PipedInputStream的缓冲中；此时，线程B通过读取PipedInputStream中的数据，就可以实现，线程A和线程B的通信。一、PipedInp...
PipedInputStream与PipedOutputStream
jackoo的专栏
06-11 2812
在Java的ＩＯ流中有一种很特殊的流就是管道流类：PipedInputStream     PipedOutputStream.这两个类的实例对象必须要通过connect方法连接.         　　其实看这么一个程序就知道了管道流类的使用方法．         //sender.java         import   java.io.*;  
深入解析Java管道流：PipedInputStream与PipedOutputStream的底层奥秘
最新发布
weixin_51786043的博客
05-14 1008
本文深入剖析了Java中的PipedInputStream和PipedOutputStream管道流机制。主要内容包括：1) 管道流的基本概念及线程通信原理；2) 环形缓冲区的底层数据结构；3) 基于synchronized和wait/notify的线程同步机制；4) 异常处理与资源关闭要点；5) 性能优化技巧；6) 常见问题排查方法；7) 多级管道处理等高级应用场景。文章揭示了管道流作为线程间字节传输桥梁的本质，强调其环形缓冲区设计、自动流量控制等核心特性，并给出正确使用建议，帮助开发者构建高效的线程通信
java中PipedOutputStream和PipedInputStream类用法
RO_wsy的专栏
11-21 4644
PipedOutputStream和PipedInputStream用于在应用程序中创建管道通信 实例： import java.io.*; public class PipedStreamTest { public static void main(String [] args) { Sender sender = new Sender(); Receiver rece
Java.PipedInputStream-PipedOutputStream
CodeAnt的专栏
12-31 2493
<br />PipedInputStream和PipedOutStream类用于在应用程序中创建管道通信<br />一个PipedOutputStream必须与一个PipedInputStream连接建立一个通信管道<br />PipedOutputStream可以向管道中写入数据，PipedInputStream可以从管道中读取PipedOutputStream写入的数据。这两个类主要用来完成线程之间的通信。一个线程的管道输入流可以从另一个线程的管道输出流中读取数据<br />PipedWriter和Pi
使用PipedOutputStream和PipedInputStream
Yerasel的专栏
08-02 747
package yerasel; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.EOFException; import java.io.
Java IO PipedInputStream与 PipedOutputStream
i余数的博客
08-19 321
PipedOutputStream 源码解析 /** * 1. 可以将一个管道输出流连接到一个管道输入流，来创建一个通信管道。管道的数据发送端为管道输出流。 * 2. 通常，一个线程将数据写入到管道输出流（PipedOutputStream），其他线程可以通过与管道输出流相连接的管道输入流（PipedInputStream）来读取数据。 * 3. 不推荐在一个线程中同时使用管道输入输出流，可能会导致死锁。 * 4. 如果从相连接的管道输入流读取数据的线程已经不再存活，那么就代表这个管道已经损坏。
PipedOutputStream和PipedInputStream
soar的博客
12-25 460
 PipedOutputStream源码： package java.io; import java.io.*; public class PipedOutputStream extends OutputStream {     // 与PipedOutputStream通信的PipedInputStream对象     private PipedInputStream sink;
PipedInputStream and PipedOutputStream 实现管道通信
zhuhezan的专栏
06-04 826
PipedInputStream 、PipedOutputStream 用于建立管道通信，既然是通信，就一定要建立连接，否则无法通信，查看API文档，他们的方法并不多，就是那几个： 以PipedInputStream为例：首先看看的构造方法：常用的有：PipedInputStream() 和 PipedInputStream(PipedOutputStrea
PipedInputStream和PipedOutputStream的使用例子
行者无疆
11-29 2584
通过学习PipedInputStream和PipedOutputStream代码，发现有两点值得我们学习： 1、notifyAll(), wait(1000); 先把对象上所有的等待线程唤醒，然后把自己睡去一定时间后醒来。 和我们平时写生产者消费者时wait(), notifyAll()有一点点不一样。 2、处理循环buffer的方式不一样，用in==-1来表示buffer为空，同时处理bu
Java里的管道输入流 PipedInputStream与管道输出流 PipedOutputStream
热门推荐
zlp1992的专栏
12-15 3万+
Java里的管道输入流PipedInputStream与管道输出流PipedOutputStream实现了类似管道的功能，用于不同线程之间的相互通信，下面说下自己的一些理解。
Java_io体系之PipedInputStream、PipedOutputStream简介、走进源码及示例——06
Oscar Chen
11-25 2451
Java_io体系之PipedInputStream/PipedOutputStream简介、走进源码及示例——06        ——管道输出流、必须建立在管道输入流之上、所以先介绍管道输出流。可以先看源码或者总结、总结写的有点Q、不喜可无视、有误的地方指出则不胜感激。 一：PipedOutputStream 1、       类功能简介： 管道字节输出流
Java IO - PipedOutputStream & PipedInputStream
一把空心菜
06-16 675
基本概念 PipedOutputStream & PipedInputStream （管道字节输入流&管道输出字节流）是配套使用的。可以将管道输出流连接到管道输入流来创建通信管道。 通常的用法是让两个线程分别操作输入输出流，由输出流向管道写入数据，然后再由输出流从管道中读取数据。不建议对这两个对象尝试使用单个线程，因为这样可能会造成该线程死锁。 继承关系： 实例探究1.生产者&消费者 定义两个线程代
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值