美文网首页
NIO 学习笔记 一

NIO 学习笔记 一

作者: Martain | 来源:发表于2020-07-23 10:41 被阅读0次

    什么是NIO?

    Java NIO( New IO,No Block IO) 是从Java 1.4版本开始引入的一个新的IO API,可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的,但是使用的方式完全不同, NIO支持面向缓冲区的、基于通道的IO操作。 NIO将以更加高效的方式进行文件的读写操作。在Java API中提供了两套NIO,一套是针对标准输入输出NIO,另一套就是网络编程NIO。

    NIO vs IO

    IO原理

    传统的io操作是面向流来读写的,当程序要读取某个文件时,会与该文件建立一个数据流管道,通过这个管道来传输数据,这个管道只支持单向的(要么输入、要么输出),当一个线程调用read()write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。

    Java-io-流 Io-输入流 io-输出流

    NIO原理

    NIO是面向缓冲区的,数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。NIO的通道是支持双向的,数据依靠缓冲区来实现数据流动。

    Java-nio-缓冲区 Java-nio-数据载入缓冲区 Java-nio-数据写入

    面向流 vs 面向缓冲区

    Java IO和NIO之间第一个最大的区别是,IO是面向流的,NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方。此外,它不能前后移动流中的数据。如果需要前后移动从流中读取的数据,需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是,还需要检查是否该缓冲区中包含所有您需要处理的数据。而且,需确保当更多的数据读入缓冲区时,不要覆盖缓冲区里尚未处理的数据

    阻塞与非阻塞IO

    Java IO的各种流是阻塞的。这意味着,当一个线程调用read()write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取。而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作,所以一个单独的线程现在可以管理多个输入和输出通道channel

    选择器

    Java NIO的选择器允许一个单独的线程来监视多个输入通道,你可以注册多个通道使用一个选择器,然后使用一个单独的线程来“选择”通道:这些通道里已经有可以处理的输入,或者选择已准备写入的通道。这种选择机制,使得一个单独的线程很容易来管理多个通道。

    Nio-selector

    缓冲区(Buffer)

    Buffer 就像一个数组,可以保存多个相同类型的数据。

    根据数据类型不同(boolean 除外) ,有以下 Buffer 常用子类:

    • ByteBuffer
    • CharBuffer
    • ShortBuffer
    • IntBuffer
    • LongBuffer
    • FloatBuffer
    • DoubleBuffer

    上述缓冲区的管理方式几乎一致,通过 allocate()获取缓冲区

    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    

    基本属性

    缓冲区中的四个核心属性:

    • capacity : 容量,表示缓冲区中最大存储数据的容量。一旦声明不能改变。

    • limit : 界限,表示缓冲区中可以操作数据的大小。(limit 后数据不能进行读写)

    • position : 位置,表示缓冲区中正在操作数据的位置。

    • mark : 标记,表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置

      0 <= mark <= position <= limit <= capacity

    基本操作

    缓冲区存取数据的两个核心方法:

    • put(): 存入数据到缓冲区中
    • get() :获取缓冲区中的数据

    基本流程

    image-20200720101633328

    示例一

    @Test
        public void test1(){
            String str = "abcde";
            
            //1. 分配一个指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            System.out.println("-----------------allocate()----------------");
            System.out.println(buf.position());
            System.out.println(buf.limit());
            System.out.println(buf.capacity());
            
            //2. 利用 put() 存入数据到缓冲区中
            buf.put(str.getBytes());
            
            System.out.println("-----------------put()----------------");
            System.out.println(buf.position());
            System.out.println(buf.limit());
            System.out.println(buf.capacity());
            
            //3. 切换读取数据模式,position会回到起始点(0),limit指向存在数据区的下一个位置
            buf.flip();
            
            System.out.println("-----------------flip()----------------");
            System.out.println(buf.position());
            System.out.println(buf.limit());
            System.out.println(buf.capacity());
            
            //4. 利用 get() 读取缓冲区中的数据
            byte[] dst = new byte[buf.limit()];
            buf.get(dst);
            System.out.println(new String(dst, 0, dst.length));
            
            System.out.println("-----------------get()----------------");
            System.out.println(buf.position());
            System.out.println(buf.limit());
            System.out.println(buf.capacity());
            
            //5. rewind() : 可重复读
            buf.rewind();
            
            System.out.println("-----------------rewind()----------------");
            System.out.println(buf.position());
            System.out.println(buf.limit());
            System.out.println(buf.capacity());
            
            //6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在,但是处于“被遗忘”状态
            buf.clear();
            
            System.out.println("-----------------clear()----------------");
            System.out.println(buf.position());
            System.out.println(buf.limit());
            System.out.println(buf.capacity());
            
            System.out.println((char)buf.get()); 
            
        }
    

    示例二

        @Test
        public void test2(){
            String str = "abcde";
            
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            buf.put(str.getBytes());
            
            buf.flip();
            
            byte[] dst = new byte[buf.limit()];
            buf.get(dst, 0, 2);
            System.out.println(new String(dst, 0, 2));
            System.out.println(buf.position());
            
            //mark() : 标记
            buf.mark();
            
            buf.get(dst, 2, 2);
            System.out.println(new String(dst, 2, 2));
            System.out.println(buf.position());
            
            //reset() : 恢复到 mark 的位置
            buf.reset();
            System.out.println(buf.position());
            
            //判断缓冲区中是否还有剩余数据
            if(buf.hasRemaining()){
                
                //获取缓冲区中可以操作的数量
                System.out.println(buf.remaining());
            }
        }
    

    直接缓冲区 vs 非直接缓冲区

    字节缓冲区要么是直接的,要么是非直接的。如果为直接字节缓冲区,则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说,在每次调用基础操作系统的一个本机 I/O 操作之前(或之后),虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中(或从中间缓冲区中复制内容)。

    直接字节缓冲区可以通过调用此类的 allocateDirect()工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外,因此,它们对应用程序的内存需求量造成的影响可能并不明显。所以,建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下,最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。

    直接字节缓冲区还可以通过 FileChannelmap()方法 将文件区域直接映射到内存中来创建。该方法返回MappedByteBufferJava 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域,则试图访问该区域不会更改该缓冲区的内容,并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。

    字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect()方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。

    非直接缓冲区

    非直接缓冲区是我们平时默认方式创建的缓冲区,读取或写入一个文件需要在内核地址空间与用户地址空间之间进行拷贝或写入,效率不是很高,但是容易控制。

    image-20200720102432682

    直接缓冲区

    直接缓冲区就在直接在物理内存上映射文件,避免了再中间缓冲区的复制与写入所带来的消耗;Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说,在每次调用基础操作系统的一个本机 I/O 操作之前(或之后),虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中(或从中间缓冲区中复制内容),创建和销毁都会比较大的消耗,而且因为内存分配在程序外部,所以对缓冲区的操作不太受控。

    image-20200720102330373

    示例

        @Test
        public void test3(){
            //分配直接缓冲区
            ByteBuffer buf = ByteBuffer.allocateDirect(1024);
            // isDirect判断是否是直接缓冲区
            System.out.println(buf.isDirect());
        }
    

    通道

    通道:用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据,因此需要配合缓冲区进行传输。

    • CPU负责IO接口的调度
    image-20200722152906618
    • DMA专门控制IO接口
    image-20200722152946925
    • Channel 代替 DMA
    image-20200722153014888

    实现类

    • java.nio.channels.Channel 接口:
      • FileChannel:用于读取、写入、映射和操作文件的通道。
      • SocketChannel:通过 TCP 读写网络中的数据。
      • ServerSocketChannel:可以监听新进来的 TCP 连接,对每一个新进来
        的连接都会创建一个SocketChannel
      • DatagramChannel:通过 UDP 读写网络中的数据通道。

    获取通道

    • Java 针对支持通道的类提供了 getChannel() 方法
    • 本地 IO:
    • FileInputStream/FileOutputStream
    • RandomAccessFile
    • 网络IO:
      • Socket
      • ServerSocket
      • DatagramSocket
    • 在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()
    • 在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()

    利用通道完成文件的复制(非直接缓冲区)

    @Test
        public void test1(){//10874-10953
            long start = System.currentTimeMillis();
            FileInputStream fis = null;
            FileOutputStream fos = null;
            //①获取通道
            FileChannel inChannel = null;
            FileChannel outChannel = null;
            try {
                fis = new FileInputStream("d:/1.mkv");
                fos = new FileOutputStream("d:/2.mkv");
                
                inChannel = fis.getChannel();
                outChannel = fos.getChannel();
                
                //②分配指定大小的缓冲区
                ByteBuffer buf = ByteBuffer.allocate(1024);
                
                //③将通道中的数据存入缓冲区中
                while(inChannel.read(buf) != -1){
                    buf.flip(); //切换读取数据的模式
                    //④将缓冲区中的数据写入通道中
                    outChannel.write(buf);
                    buf.clear(); //清空缓冲区
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(outChannel != null){
                    try {
                        outChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                if(inChannel != null){
                    try {
                        inChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                if(fos != null){
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                if(fis != null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("耗费时间为:" + (end - start));
        }
    

    使用直接缓冲区完成文件的复制(内存映射文件)

    @Test
        public void test2() throws IOException{//2127-1902-1777
            long start = System.currentTimeMillis();
            
            FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
            FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
            
            //内存映射文件
            MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
            MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());
            
            //直接对缓冲区进行数据的读写操作
            byte[] dst = new byte[inMappedBuf.limit()];
            inMappedBuf.get(dst);
            outMappedBuf.put(dst);
            
            inChannel.close();
            outChannel.close();
            
            long end = System.currentTimeMillis();
            System.out.println("耗费时间为:" + (end - start));
        }
    

    通道间传输

    transferFrom()

    transferTo()

        @Test
        public void test3() throws IOException{
            FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
            FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
            
    //      inChannel.transferTo(0, inChannel.size(), outChannel);
            outChannel.transferFrom(inChannel, 0, inChannel.size());
            
            inChannel.close();
            outChannel.close();
        }
    

    分散和聚集

    分散读取(Scattering Reads):将通道中的数据分散到多个缓冲区中

    聚集写入(Gathering Writes):将多个缓冲区中的数据聚集到通道中

    @Test
        public void test4() throws IOException{
            RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
            
            //1. 获取通道
            FileChannel channel1 = raf1.getChannel();
            
            //2. 分配指定大小的缓冲区
            ByteBuffer buf1 = ByteBuffer.allocate(100);
            ByteBuffer buf2 = ByteBuffer.allocate(1024);
            
            //3. 分散读取
            ByteBuffer[] bufs = {buf1, buf2};
            channel1.read(bufs);
            
            for (ByteBuffer byteBuffer : bufs) {
                byteBuffer.flip();
            }
            
            System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
            System.out.println("-----------------");
            System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
            
            //4. 聚集写入
            RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
            FileChannel channel2 = raf2.getChannel();
            
            channel2.write(bufs);
        }
    

    字符集:Charset

        @Test
        public void test6() throws IOException{
            Charset cs1 = Charset.forName("GBK");
            
            //获取编码器
            CharsetEncoder ce = cs1.newEncoder();
            
            //获取解码器
            CharsetDecoder cd = cs1.newDecoder();
            
            CharBuffer cBuf = CharBuffer.allocate(1024);
            cBuf.put("尚硅谷威武!");
            cBuf.flip();
            
            //编码
            ByteBuffer bBuf = ce.encode(cBuf);
            
            for (int i = 0; i < 12; i++) {
                System.out.println(bBuf.get());
            }
            
            //解码
            bBuf.flip();
            CharBuffer cBuf2 = cd.decode(bBuf);
            System.out.println(cBuf2.toString());
            
            System.out.println("------------------------------------------------------");
            
            Charset cs2 = Charset.forName("GBK");
            bBuf.flip();
            CharBuffer cBuf3 = cs2.decode(bBuf);
            System.out.println(cBuf3.toString());
        }
    

    NIO的非阻塞式网络通讯

    一、使用 NIO 完成网络通信的三个核心:

      1. 通道(Channel):负责连接
        1. java.nio.channels.Channel 接口:

          1. |--SelectableChannel

          2. |--SocketChannel

          3. |--ServerSocketChannel

          4. |--DatagramChannel

          5. |--Pipe.SinkChannel

          6. |--Pipe.SourceChannel

      1. 缓冲区(Buffer):负责数据的存取
      1. 选择器(Selector):是 SelectableChannel 的多路复用器。用于监控 SelectableChannel 的 IO 状况

    阻塞与非阻塞

    传统的 IO 流都是阻塞式的。也就是说,当一个线程调用 read() 或 write()时,该线程被阻塞,直到有一些数据被读取或写入,该线程在此期间不能执行其他任务。因此,在完成网络通信进行 IO 操作时,由于线程会阻塞,所以服务器端必须为每个客户端都提供一个独立的线程进行处理,当服务器端需要处理大量客户端时,性能急剧下降。

    网络read-write阻塞

    Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时,若没有数据可用时,该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作,所以单独的线程可以管理多个输入和输出通道。因此, NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。

    网络请求分配多线程 Selector

    示例:NIO阻塞

    //客户端
        @Test
        public void client() throws IOException{
            //1. 获取通道
            SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
            
            FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
            
            //2. 分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            //3. 读取本地文件,并发送到服务端
            while(inChannel.read(buf) != -1){
                buf.flip();
                sChannel.write(buf);
                buf.clear();
            }
            
            //4. 关闭通道
            inChannel.close();
            sChannel.close();
        }
        
        //服务端
        @Test
        public void server() throws IOException{
            //1. 获取通道
            ServerSocketChannel ssChannel = ServerSocketChannel.open();
            
            FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
            
            //2. 绑定连接
            ssChannel.bind(new InetSocketAddress(9898));
            
            //3. 获取客户端连接的通道
            SocketChannel sChannel = ssChannel.accept();
            
            //4. 分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            //5. 接收客户端的数据,并保存到本地
            while(sChannel.read(buf) != -1){
                buf.flip();
                outChannel.write(buf);
                buf.clear();
            }
            
            //6. 关闭通道
            sChannel.close();
            outChannel.close();
            ssChannel.close();
            
        }
    

    示例:NIO2阻塞

    //客户端
        @Test
        public void client() throws IOException{
            SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
            
            FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
            
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            while(inChannel.read(buf) != -1){
                buf.flip();
                sChannel.write(buf);
                buf.clear();
            }
            
            sChannel.shutdownOutput();
            
            //接收服务端的反馈
            int len = 0;
            while((len = sChannel.read(buf)) != -1){
                buf.flip();
                System.out.println(new String(buf.array(), 0, len));
                buf.clear();
            }
            
            inChannel.close();
            sChannel.close();
        }
        
        //服务端
        @Test
        public void server() throws IOException{
            ServerSocketChannel ssChannel = ServerSocketChannel.open();
            
            FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
            
            ssChannel.bind(new InetSocketAddress(9898));
            
            SocketChannel sChannel = ssChannel.accept();
            
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            while(sChannel.read(buf) != -1){
                buf.flip();
                outChannel.write(buf);
                buf.clear();
            }
            
            //发送反馈给客户端
            buf.put("服务端接收数据成功".getBytes());
            buf.flip();
            sChannel.write(buf);
            
            sChannel.close();
            outChannel.close();
            ssChannel.close();
        }
    
    

    示例:NIO非阻塞

    //客户端
        @Test
        public void client() throws IOException{
            //1. 获取通道
            SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));
            
            //2. 切换非阻塞模式
            sChannel.configureBlocking(false);
            
            //3. 分配指定大小的缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            //4. 发送数据给服务端
            Scanner scan = new Scanner(System.in);
            
            while(scan.hasNext()){
                String str = scan.next();
                buf.put((new Date().toString() + "\n" + str).getBytes());
                buf.flip();
                sChannel.write(buf);
                buf.clear();
            }
            
            //5. 关闭通道
            sChannel.close();
        }
    
        //服务端
        @Test
        public void server() throws IOException{
            //1. 获取通道
            ServerSocketChannel ssChannel = ServerSocketChannel.open();
            
            //2. 切换非阻塞模式
            ssChannel.configureBlocking(false);
            
            //3. 绑定连接
            ssChannel.bind(new InetSocketAddress(9898));
            
            //4. 获取选择器
            Selector selector = Selector.open();
            
            //5. 将通道注册到选择器上, 并且指定“监听接收事件”
            ssChannel.register(selector, SelectionKey.OP_ACCEPT);
            
            //6. 轮询式的获取选择器上已经“准备就绪”的事件
            while(selector.select() > 0){
                
                //7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                
                while(it.hasNext()){
                    //8. 获取准备“就绪”的是事件
                    SelectionKey sk = it.next();
                    
                    //9. 判断具体是什么事件准备就绪
                    if(sk.isAcceptable()){
                        //10. 若“接收就绪”,获取客户端连接
                        SocketChannel sChannel = ssChannel.accept();
                        
                        //11. 切换非阻塞模式
                        sChannel.configureBlocking(false);
                        
                        //12. 将该通道注册到选择器上
                        sChannel.register(selector, SelectionKey.OP_READ);
                    }else if(sk.isReadable()){
                        //13. 获取当前选择器上“读就绪”状态的通道
                        SocketChannel sChannel = (SocketChannel) sk.channel();
                        
                        //14. 读取数据
                        ByteBuffer buf = ByteBuffer.allocate(1024);
                        
                        int len = 0;
                        while((len = sChannel.read(buf)) > 0 ){
                            buf.flip();
                            System.out.println(new String(buf.array(), 0, len));
                            buf.clear();
                        }
                    }
                    
                    //15. 取消选择键 SelectionKey
                    it.remove();
                }
            }
        }
    

    示例:NIO2非阻塞

    @Test
        public void send() throws IOException{
            DatagramChannel dc = DatagramChannel.open();
            
            dc.configureBlocking(false);
            
            ByteBuffer buf = ByteBuffer.allocate(1024);
            
            Scanner scan = new Scanner(System.in);
            
            while(scan.hasNext()){
                String str = scan.next();
                buf.put((new Date().toString() + ":\n" + str).getBytes());
                buf.flip();
                dc.send(buf, new InetSocketAddress("127.0.0.1", 9898));
                buf.clear();
            }
            
            dc.close();
        }
        
        @Test
        public void receive() throws IOException{
            DatagramChannel dc = DatagramChannel.open();
            
            dc.configureBlocking(false);
            
            dc.bind(new InetSocketAddress(9898));
            
            Selector selector = Selector.open();
            
            dc.register(selector, SelectionKey.OP_READ);
            
            while(selector.select() > 0){
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                
                while(it.hasNext()){
                    SelectionKey sk = it.next();
                    
                    if(sk.isReadable()){
                        ByteBuffer buf = ByteBuffer.allocate(1024);
                        
                        dc.receive(buf);
                        buf.flip();
                        System.out.println(new String(buf.array(), 0, buf.limit()));
                        buf.clear();
                    }
                }
                
                it.remove();
            }
        }
    

    管道

    Java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道,从source通道读取。

    @Test
        public void test1() throws IOException{
            //1. 获取管道
            Pipe pipe = Pipe.open();
            
            //2. 将缓冲区中的数据写入管道
            ByteBuffer buf = ByteBuffer.allocate(1024);
        
            Pipe.SinkChannel sinkChannel = pipe.sink();
            buf.put("通过单向管道发送数据".getBytes());
            buf.flip();
            sinkChannel.write(buf);
            
            //3. 读取缓冲区中的数据
            Pipe.SourceChannel sourceChannel = pipe.source();
            buf.flip();
            int len = sourceChannel.read(buf);
            System.out.println(new String(buf.array(), 0, len));
            
            sourceChannel.close();
            sinkChannel.close();
        }
    

    参考资料

    jenkov的NIO教程

    简友文章

    相关文章

      网友评论

          本文标题:NIO 学习笔记 一

          本文链接:https://www.haomeiwen.com/subject/gppclktx.html