Java NIO —— 管道（Channel）

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： # Java NIO 文章标签： java piped
转载请注明出处——https://blog.csdn.net/chy555chy
本文链接：https://blog.csdn.net/chy555chy/article/details/53426011
版权

管道的定义

在Linux中，管道是一种使用非常频繁的通信机制。从本质上说，管道也是一种文件，但它又和一般的文件有所不同，管道可以克服使用文件进行通信的两个问题，具体表现为：

  • 限制管道的大小。实际上，管道是一个固定大小的缓冲区。在Linux中，该缓冲区的大小为1页，即4K字节，使得它的大小不像文件那样不加检验地增长。使用单个固定缓冲区也会带来问题，比如在写管道时可能变满，当这种情况发生时，随后对管道的write()调用将默认地被阻塞，等待某些数据被读取，以便腾出足够的空间供write()调用写。
  • 读取进程也可能工作得比写进程快。当所有当前进程数据已被读取时，管道变空。当这种情况发生时，一个随后的read()调用将默认地被阻塞，等待某些数据被写入，这解决了read()调用返回文件结束的问题。

管道有如下特性：

  • 管道可以把一个进程的标准输出流与另一个进程的标准输入流连接起来。
  • 从管道读数据是一次性操作，数据一旦被读，它就从管道中被抛弃，释放空间以便写更多的数据。
  • 管道只能半双工通信，即某一时刻只能单向传输。要实现父子进程双方互动通信，需要定义两个管道。
  • 管道只能用于有亲缘关系进程间的通信。要实现独立进程间的通信可参照有名管道（FIFO）。

Linux/Windows的命令行中的管道

通过管道将命令执行的结果输出到文本：命令 > 文本（其中”>”为管道符号）。

例如，以下命令将当前目录下的文件信息输出到result.txt文本中。
Linux下，ls > result.txt
Windows下，dir > result.txt

Java中的管道

Java 提供管道功能，但只能用于线程间通讯。实现管道通信的类有两组：PipedInputStream 和 PipedOutputStream 或者是 PipedReader 和 PipedWriter。

PipedInputStream & PipedOutputStream

package com.demo.test;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PipedDemo {
    private static final int BUFF_SIZE = 255;
    private static final int LOOP_COUNT = 10;

    static class InputThread implements Runnable {

        private PipedInputStream pis;

        public InputThread(PipedInputStream pis) {
            this.pis = pis;
        }

        @Override
        public void run() {
            byte[] buffer = new byte[BUFF_SIZE];
            int len = -1;
            do {
                try {
                    len = pis.read(buffer);
                    System.out.println("len=" + len + ", buffer=" + new String(buffer));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } while (len != -1);
            try {
                pis.close();
                System.out.println("PipedIutputStream close");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    static class OutputThread implements Runnable {

        private PipedOutputStream pos;

        public OutputThread(PipedOutputStream pos) {
            this.pos = pos;
        }

        @Override
        public void run() {
            Date date = new Date();
            for (int i = 0; i < LOOP_COUNT; i++) {
                try {
                    String str = "(" + i + ")" + date.toString();
                    pos.write(str.getBytes());
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                pos.close();
                System.out.println("PipedOutputStream close");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void testPipedStream() {
        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream();
        try {
            // 连接“输入”、“输出”流，下面2个方法任选
            pis.connect(pos);
            // pos.connect(pis);
        } catch (IOException e) {
            e.printStackTrace();
        }
        int nThreads = 2;
        ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
        executorService.execute(new InputThread(pis));
        executorService.execute(new OutputThread(pos));
    }

    public static void main(String[] args) {
        testPipedStream();
    }
}

输出

PipedOutputStream close
len=255, buffer=(0)Fri Dec 02 10:58:27 CST 2016(1)Fri Dec 02 10:58:27 CST 2016(2)Fri Dec 02 10:58:27 CST 2016(3)Fri Dec 02 10:58:27 CST 2016(4)Fri Dec 02 10:58:27 CST 2016(5)Fri Dec 02 10:58:27 CST 2016(6)Fri Dec 02 10:58:27 CST 2016(7)Fri Dec 02 10:58:27 CST 2016(8)Fri 
len=55, buffer=Dec 02 10:58:27 CST 2016(9)Fri Dec 02 10:58:27 CST 2016ST 2016(2)Fri Dec 02 10:58:27 CST 2016(3)Fri Dec 02 10:58:27 CST 2016(4)Fri Dec 02 10:58:27 CST 2016(5)Fri Dec 02 10:58:27 CST 2016(6)Fri Dec 02 10:58:27 CST 2016(7)Fri Dec 02 10:58:27 CST 2016(8)Fri 
len=-1, buffer=Dec 02 10:58:27 CST 2016(9)Fri Dec 02 10:58:27 CST 2016ST 2016(2)Fri Dec 02 10:58:27 CST 2016(3)Fri Dec 02 10:58:27 CST 2016(4)Fri Dec 02 10:58:27 CST 2016(5)Fri Dec 02 10:58:27 CST 2016(6)Fri Dec 02 10:58:27 CST 2016(7)Fri Dec 02 10:58:27 CST 2016(8)Fri 
PipedIutputStream close

PipedReader & PipedWriter

package com.demo.test;

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PipedDemo {
    private static final int BUFF_SIZE = 255;
    private static final int LOOP_COUNT = 10;

    static class ReaderThread implements Runnable {

        private PipedReader pr;

        public ReaderThread(PipedReader pr) {
            this.pr = pr;
        }

        @Override
        public void run() {
            char[] buffer = new char[BUFF_SIZE];
            int len = -1;
            do {
                try {
                    len = pr.read(buffer);
                    System.out.println("len=" + len + ", buffer=" + new String(buffer));
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } while (len != -1);
            try {
                pr.close();
                System.out.println("PipedReader close");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    static class WriterThread implements Runnable {

        private PipedWriter pw;

        public WriterThread(PipedWriter pw) {
            this.pw = pw;
        }

        @Override
        public void run() {
            Date date = new Date();
            for (int i = 0; i < LOOP_COUNT; i++) {
                try {
                    String str = "(" + i + ")" + date.toString();
                    pw.write(str);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                pw.close();
                System.out.println("PipedWriter close");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void testPipedWrapper() {
        // 同样是两种初始化连接方式
        // PipedReader pr = new PipedReader();
        // try {
        // PipedWriter pw = new PipedWriter(pr);
        // } catch (IOException e) {
        // e.printStackTrace();
        // }
        PipedWriter pw = new PipedWriter();
        try {
            PipedReader pr = new PipedReader(pw);
            int nThreads = 2;
            ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
            executorService.execute(new ReaderThread(pr));
            executorService.execute(new WriterThread(pw));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        testPipedStream();
        try {
            Thread.sleep(3000);
            System.out.println();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        testPipedWrapper();
    }
}

输出

PipedWriter close
len=255, buffer=(0)Fri Dec 02 10:58:30 CST 2016(1)Fri Dec 02 10:58:30 CST 2016(2)Fri Dec 02 10:58:30 CST 2016(3)Fri Dec 02 10:58:30 CST 2016(4)Fri Dec 02 10:58:30 CST 2016(5)Fri Dec 02 10:58:30 CST 2016(6)Fri Dec 02 10:58:30 CST 2016(7)Fri Dec 02 10:58:30 CST 2016(8)Fri 
len=55, buffer=Dec 02 10:58:30 CST 2016(9)Fri Dec 02 10:58:30 CST 2016ST 2016(2)Fri Dec 02 10:58:30 CST 2016(3)Fri Dec 02 10:58:30 CST 2016(4)Fri Dec 02 10:58:30 CST 2016(5)Fri Dec 02 10:58:30 CST 2016(6)Fri Dec 02 10:58:30 CST 2016(7)Fri Dec 02 10:58:30 CST 2016(8)Fri 
len=-1, buffer=Dec 02 10:58:30 CST 2016(9)Fri Dec 02 10:58:30 CST 2016ST 2016(2)Fri Dec 02 10:58:30 CST 2016(3)Fri Dec 02 10:58:30 CST 2016(4)Fri Dec 02 10:58:30 CST 2016(5)Fri Dec 02 10:58:30 CST 2016(6)Fri Dec 02 10:58:30 CST 2016(7)Fri Dec 02 10:58:30 CST 2016(8)Fri 
PipedReader close
福州司马懿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java select 选择器_Java NIO——Selector选择器
weixin_30035343的博客
02-27 611
一、简介1.1、Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector(选择器)1.2、Selector 能够检测多个注册的通道上是否有事件发生(注意：多个Channel以事件的方式可以注册到同一个Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。1...
java NIO——Pipe
ccoran的博客
12-11 211
概述 Java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。 demo // 创建管道 Pipe pipe = Pipe.open(); // 向管道写输入，获取sink通道 Pipe.SinkChannel sinkChannle = pipe.sink(); ByteBuffer bu...
Java NIO——Selector机制解析一《转》
todd-fly
07-11 166
一、  前言   自从J2SE 1.4版本以来，JDK发布了全新的I/O类库，简称NIO，其不但引入了全新的高效的I/O机制，同时，也引入了多路复用的异步模式。NIO的包中主要包含了这样几种抽象数据类型：   Buffer：包含数据且用于读写的线形表结构。其中还提供了一个特殊类用于内存映射文件的I/O操作。 Charset：它提供Unicode字符串影射到字节序列以及逆映射的操...
NIO —— Channel (通道、管道) 学习
猎人在吃肉
02-27 9763
Channel (通道、管道) A、通道（Channel） 用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输。 B、通道的主要实现类 java.nio.channels.Channel 接口： |--FileChannel |--SocketChannel |--ServerSocketChannel |...
java中的管道 nio_JAVA NIO知识点总结(7)——管道Pipe
weixin_32334209的博客
02-16 191
管道(Pipe)Java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。 使用方法(1)创建管道通过Pipe.open()方法打开管道。(2)向管道写数据要向管道写数据，需要访问sink通道。Pipe.SinkChannel sinkChannel = pipe.sink();(3)通过调用SinkCh...
Java NIO——NIO与IO的区别
qq_38386085的博客
08-07 370
1.Java NIO简介： Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓存区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。 2Java NIO与IO的主要区别： 为什么说原来的IO是面向流呢？因为无论是磁盘文...
Java 基础 —— NIO 学习
IT__learning的博客
09-11 412
一、NIO 简介 java.nio 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)。新增了许多用于处理输入输出的类，这些类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写，新增了满足 NIO 的功能。 NIO 以块的方式处理数据，块 IO 的效率比流 IO 的效率高很多。　 NIO 是非阻塞的，同时实现了 IO 多路复用。NIO
Java NIO——Selector机制源码分析
chunlong1003的博客
10-29 85
一直不明白pipe是如何唤醒selector的，所以又去看了jdk的源码（openjdk下载），整理了如下： 以Java nio自带demo : OperationServer.javaOperationClient.java（见附件） 其中server端的核心代码： public...
Java NIO —— Buffer（缓冲区）
02-26 1111
Buffer是一个抽象类，位于java.nio包中，主要用作缓冲区。注意：Buffer是非线程安全类。 缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。 NIO 有以下几种Buffer类型： ByteBuffer MappedByteBuffer CharBuffer Doub...
Java NIO——与传统IO文件复制的效率比较（channel.transferTo、Files.copy 、channel.write）
司马懿的西山居
10-18 9318
IO与NIO操作效率对比（网上的说法千篇一律，99%都是错的，没经过自己的验证，正确的解释如下） 复制文件的情况： 注意：Files.copy和传统IO代码基本一样，只是它开辟的缓冲区大小较大，为8192（基本是缓冲区开的越大越快，但是也吃内存）当缓冲区（<1024）和数据量比较小（<10KB）时，传统IO 最为高效 效率上：传统IO > channel.transferTo > Files.c
Java NIO —— Selector（用于SocketChannel）
司马懿的西山居
12-02 6523
使用Selector的原因Selector（选择器）是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。事实上，可以只用一个线程处理所有的通道。对于操作系统来说，线程之间上下文切换的开销很大，而且每个线程都要占用
Java NIO —— 用 Path 取代 File
司马懿的西山居
02-24 2125
Java7中文件IO发生了很大的变化，专门引入了很多新的类：import java.nio.file.DirectoryStream; import java.nio.file.FileSystem; import java.nio.file.FileSystems; import java.nio.file.Files; import java.nio.file.Path; import java
Java NIO —— TCP套接字（ServerSocketChannel & SocketChannel）
司马懿的西山居
12-02 1930
package com.demo.test;import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; im
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 243
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 984
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 94
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 525
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值