网络编程--OS层级NIO的Channel和Buffer

最新推荐文章于 2024-03-21 17:17:20 发布
最新推荐文章于 2024-03-21 17:17:20 发布
阅读量281 收藏 2
点赞数 1
分类专栏： 网络编程 互联网 计算机常识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31142237/article/details/117428281
版权

网络编程–OS层级NIO的Channel和Buffer

上篇文章讲述了BIO同步阻塞模型，大家都知道正是因为阻塞的原因，针对多连接，必须要用多线程去处理每一个连接，形成了每连接对应每线程的线程。由此，在多连接的场景下，过多的线程会线程内存浪费以及CPU的调度消耗。

于是内核需要升级，将accept 和 read调用能设置成非阻塞的。服务器端建立连接后，内核程序会把该线程返回的文件描述符fd打上非阻塞标记NONBLOCKING。先看下抓包效果
在这里插入图片描述
在这里插入图片描述
由上面我们可以看出来，操作系统内核升级之后，确实提供了，不阻塞的方式。
既然这样的话我们就可以通过一个线程去处理多个连接了，大致的实现模式是这样的：
在这里插入图片描述
通过一次while去接受连接以及处理连接读写，因为accept和recv都不阻塞了。

以上是C程序大致的伪代码模型，下面说说具体java中怎么实现让设置accept和recv不阻塞，也就是打上NONBLOCKING标记。
java 对于socketchannel提供socketChannel.configureBlocking(false）的方法，去实现非阻塞。看下源码：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
通过源码也是可以清晰的看出来，最后就是通过外部方法configureBlocking的调用，去实现的非阻塞设置，参数 FileDescriptor 文件描述符，就是对指定的文件描述符是否标记为非阻塞状态，和上面上述的相对应。

在jdk1.4之后引入了新的IO–NEW NIO，其中包括Channel、Buffer、Selector三大组件。今天主要讲解下Channel和Buffer，以及实现通讯。因为Selector主要是对多路复用器的封装，留在我们后面讲解，正好把BIO的演变过程说清楚。

Channel 通道

通道表示打开到 IO 设备(例如：文件、套接字)的连接。可以理解为客户端 – 服务端，之间建立起的路。起到了数据读写的作用，但是Channel是不能直接往两端写的，选要一个缓冲区Buffer。
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210531205912569.png在这里插入图片描述
对于以前我们BIO，它的数据读写时通过数据流的形式，比如输入流、输出流。
但是NIO他是基于通道和缓冲区去读写数据的。有什么优势呢？（此NIO暂时不带seletor）

  1. Channel是双向的既可以从缓冲区读，也往缓冲区可以写。（虽然通道是双向的。但输入流的通道只能用于读取数据到缓冲区，输出流的通道用于把缓冲区数据写入通道。）
  2. Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方；而NIO时基于通道和缓冲区的，可以前后移动缓冲区数据，灵活性很强。
  3. Buffer中还提供了一一种文件映射mmap技术，减少了一次文件从用户缓冲区到内核缓冲区的copy过程。（下面到Buffer时候会说到）
  4. 非阻塞IO（Non Blocking IO）

Channel组件的实现一共分为以下几种：

  1. FileChannel(file) – 主要针对文件操作的通道，上面说到文件映射内存区，也只有它才能创建。而FileChannel是不能设置为非阻塞的，因为它没有继承AbstractSelectableChannel
  2. DatagramChannel(UDP) – 通过UDP读写网络中的数据，用的少
  3. SocketChannel(TCP) — TCP网络通讯客户端通道，可以设置为非阻塞
  4. ServerSocketChannel(TCP) – TCP网络通讯服务器端通道，可以设置为非阻塞

代码简单演示下FileChannel的使用：

 public static void main(String[] args) throws IOException {
        // 先拿到一个文件流，输入流
        FileInputStream fileInputStream = new FileInputStream("F:\\ceshi.txt");
        // 得到输入流对应的读通道
        FileChannel fileChannel =fileInputStream.getChannel();
        // 申请一个缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 将通道数据读取到缓冲区
        fileChannel.read(byteBuffer);
        // 读取缓冲区数据
        System.out.println(new String(byteBuffer.array()));

        // 切换模式
        byteBuffer.flip();
        // 将读取到的数据写入文件
        // 拿到有个文件输出流
        FileOutputStream outputStream = new FileOutputStream("F:\\ceshiout.txt");
        // 创建写通道
        FileChannel fileChannelos =outputStream.getChannel();

        // 通道数据写入缓存区
        fileChannelos.write(byteBuffer);
    }

代码简单演示下ServerSocketChannel的创建和非阻塞设置（结合buffer下面会演示详细的）：

 // 1. 创建套接字通道
        ServerSocketChannel ss = ServerSocketChannel.open();
        // 2.将该通道设置为非阻塞模式 --> 源码父类AbstractSelectableChannel 中 configureBlocking 实现了非阻塞设置
        ss.configureBlocking(true);
        // 3.绑定连接端口
        ss.bind(new InetSocketAddress("127.0.0.1",9999));
Buffer缓冲区

缓冲区是一块可以写入数据，然后可以从中读取数据的内存，本质上就是一个数组。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。

个人觉得Buffer是NIO相对核心的组件。
刚才说了Channel是不能够直接读写客户端和服务器端数据的，中间需要有一个buffer缓冲区存储数据，让Channel读写。
在这里插入图片描述
从数据类型上区分NIO Buffer主要分为以下几类：

  1. ByteBuffer (常用)
  2. CharBuffer
  3. DoubleBuffer
  4. FloatBuffer
  5. IntBuffer
  6. LongBuffer
  7. ShortBuffer

这些Buffer覆盖了你能通过IO发送的基本数据类型：byte、short、int、long、float、double和char。
说一下Buffer数组结构和相关的一些方法：
在这里插入图片描述（网上找了个图）

  1. capacity
    作为一个内存块，Buffer有个固定的最大值，就是capacity。Buffer只能写capacity个byte、long、char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据
  2. position
    当写数据到Buffer中时，position表示当前的位置。初始的position值为0。当一个byte、long等数据写到Buffer后，position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1。当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。
  3. limit
    在写模式下，Buffer的limit表示最多能往Buffer里写多少数据。写模式下，limit等于capacity。当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。
  4. clear
    清空缓冲区并返回对缓冲区的应用，其实是将位置设置到0，不会删除缓冲区数据，下次数据进来会更新。
  5. hasReamining()
    判断缓冲区理是否还有元素
  6. mark()
    对缓冲区设置标记
  7. remaining()
    返回position和limit位置之间的元素个数
  8. reset
    将位置position 转到以前设置的mark所在的位置
  9. flip
    为缓冲区的界限设置为当前位置，并将当前位置重置为0。（切换模式）
    以上方法的使用数组的变化网上很多文章，大家可以去看看，我这边就不做分析了，简单放下代码示例看看：
   // 1. 分配一个缓冲区大小为10的字节数组
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println(buffer.position()); // 返回当前指针位置  0
        System.out.println(buffer.limit()); //    返回缓冲区最大限制 10
        System.out.println(buffer.capacity()); // 返回缓冲区容量大小 10

        // 向缓冲区添加元素
        buffer.put("hello".getBytes());
        System.out.println(buffer.position()); // 返回当前指针位置  0
        System.out.println(buffer.limit()); //    返回缓冲区最大限制 10
        System.out.println(buffer.capacity()); // 返回缓冲区容量大小 10

        // 读取缓冲区数据
        buffer.flip(); // 为缓冲区的界限设置为当前位置，并将当前位置重置为0(切换读模式)

Buffer站在内存分配的角度分为：
1.HeapByteBuffer ： 堆内缓冲区。（就是buffer缓冲区分配在堆内–用户空间）
ByteBuffer buffer = ByteBuffer.allocate(10);
在这里插入图片描述
在这里插入图片描述

  1. DirectByteBuffer ：对外缓冲区。 （就是buffer缓冲区分配在堆外–用户空间）
    ByteBuffer buffer = ByteBuffer.allocateDirect(10);![在这里插在这里插入图片描述
    同时
    在这里插入图片描述
  2. MappedByteBuffer 文件映射缓冲区（核心），它也属于对外内存。基于mmap+write方式实现。
    在这里插入图片描述
    好处什么？
    用户要想获取磁盘信息，必须系统调用进行一次用户态和内核态的切换，将文件从磁盘通过DMA复制到内核缓冲区，再copy到用户缓存区。而mmap系统调用就是创建了一个用户和内核缓冲区共享的内存空间，就免去了一次拷贝的过程。

具体讲述如下：
普通的IO要想从硬盘获取文件信息，然后再输出到网卡的过程是这样的。
在这里插入图片描述
经历了4次copy，其中2次是DMA复制，2次是CPU复制。

在NIO中零拷贝通过**fileChannel.map()**创建一个MappedByteBuffer缓冲区，底层通过mmap+write方式实现，文件映射之后是这样的：
在这里插入图片描述
从以上的4次copy 编程了3次copy，读写性能大大提高了，用户端直接读写磁盘（当然了中间还有个DMA）,不需要频繁耗费性能去系统调用切换内核态copy文件。（CPU拷贝也是很消耗CPU性能的工作）

- MMAP 有哪些注意事项？

MMAP 使用时必须实现指定好内存映射的大小，mmap 在 Java 中一次只能映射 1.5~2G 的文件内存，其中RocketMQ中限制了单文件1G来避免这个问题 MMAP 可以通过 force() 来手动控制，但控制不好也会有大麻烦 MMAP 的回收问题，当MappedByteBuffer 不再需要时，可以手动释放占用的虚拟内存，但使用方式非常的麻烦。
fileChannel.map之后会立刻获得一个 1.5G 的文件，但此时文件的内容全部是 0（字节 0），之后对内存中 MappedByteBuffer 做的任何操作，都会被最终映射到文件之中。

以上是NIO中零拷贝实现原理。通过fileChannel.map()创建共享空间，系统调用mmap技术实现。

现在补充下DMA知识：
直接内存访问 DMA （Direct Memory Access）：
DMA允许外设设备和内存存储器之间直接进行IO数据传输，其过程不需要CPU的参与。
在这里插入图片描述
现在代码看下NIO中MappedByteBuffer的用法：


//MappedByteBuffer 便是MMAP的操作类(获得一个 1.5G 的文件)
MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1.5 * 1024 * 1024 * 1024);
// write
byte[] data = new byte[4];
int position = 8;
mappedByteBuffer.put(data)

 //复制图片，利用直接缓存区
    public void test() throws Exception{
        FileChannel inChannel = FileChannel.open(Paths.get("D:\\1.jpg"), StandardOpenOption.READ);
        FileChannel outChannel = FileChannel.open(Paths.get("D:\\2.jpg"), StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);
        outChannel.transferFrom(inChannel,0, inChannel.size()); 
        inChannel.close();
        outChannel.close();
    }

最后给上网络非阻塞IO代码实现（不用多路复用器）：
服务器端：

public static void main(String[] args) throws IOException {
        List<SocketChannel>  clients = new ArrayList<SocketChannel>();
        // 1. 创建套接字通道
        ServerSocketChannel ss = ServerSocketChannel.open();
        // 2.将该通道设置为非阻塞模式 --> 源码父类AbstractSelectableChannel 中 configureBlocking 实现了非阻塞设置
        ss.configureBlocking(true);
        // 3.绑定连接端口
        ss.bind(new InetSocketAddress("127.0.0.1",9999));
        // 4.接受客户端连接
        while (true){
            SocketChannel channel = ss.accept(); // 非阻塞
//            System.out.println("===============接受连接=================="+channel);
            if(channel==null){

            }else{
                // 设置客户端通道为非阻塞
                channel.configureBlocking(false);
                System.out.println(channel.socket().getPort());

                // 将一个个连接加入到集合中
                clients.add(channel);
            }
            // 遍历集合对一个个连接，看是否有消息过来
            for(SocketChannel socketChannel : clients){
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
                if(socketChannel==null){
                    continue;
                }
                // 创建一个缓冲区
                int num = socketChannel.read(byteBuffer);  // 非阻塞
//                System.out.println("===============服务连接数据=================="+num);
                if(num>0){
                    byteBuffer.flip();
                    byte[] bytes = new byte[byteBuffer.limit()];
                    byteBuffer.get(bytes);
                    System.out.println(new String(bytes));
                    byteBuffer.clear();
                }
            }
        }
    }

客户端：

public static void main(String[] args) throws IOException {
        // 1. 创建客户端套接字通道，且设置非阻塞
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        // 2. 连接服务器端
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9999));
        System.out.println(socketChannel);
        if (socketChannel.finishConnect()){
            System.out.println("链接成功");
            // 3. 发送信息到服务器端
            // 创建缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
            // 向缓冲区写入数据
            byteBuffer.put("你好啊".getBytes());
            byteBuffer.flip();
            // 缓冲区写入通道
            socketChannel.write(byteBuffer);
            socketChannel.close();
        }else {
            System.out.println("没连上");
        }
    }

总结：
NIO中通过channel和buffer的实现，可以把accept和read设置为非阻塞，这样可以规避BIO模型中多线程CPU消耗和线程浪费问题。

但是同时我们也发现了其中的弊端：
如果有10000个连接进来，虽然不阻塞了，但是每次我都要对着10000个连接进行全面的遍历，去获取有事件的连接数据，可能只有1 2个连接有消息事件，但是却要全部遍历了。而且大家都清楚，每一次遍历读取数据都是一次系统调用，所以这就产生了很多无意义的性能消耗，浪费事件和资源。

解决思想：
如果有10000个连接进来了，我每次不去遍历所有连接，而是去遍历有消息事件的连接就行了哈。
这就是多路复用器的设计思想，下篇介绍！

Survivor001
关注
专栏目录
Java NIO(Java Non-Blocking IO:非阻塞式IO)(1)
xp_xpxp的博客
04-28 969
java nio 三大核心组件原理
网络编程底层
arron121741的博客
03-03 1674
TCP，HTTP协议，负载均衡，IO模型
OS------缓冲区管理
Helloirbd的博客
12-12 865
缓冲管理的作用： 缓和CPU和I/O设备之间速度不匹配的矛盾 减少对CPU的中断频率 解决数据粒度不匹配的问题 提高CPU和I/O设备之间的并行性  提高CPU的利用效率，使用字符设备和块设备配置相应的缓冲区 什么是字符设备，块设备？ 链接：https://blog.csdn.net/qq_27840681/article/details/77567094 字符设备特点 一个字节一个...
网络编程--NIO--Channel
qq_43470725的博客
11-22 1247
参考：https://www.cnblogs.com/ostenant/p/9695183.html 通道（Channel）： 　　由java.nio.channels包定义的，Channel表示IO源与目标打开的连接，Channel类似于传统的“流”，只不过Channel本身不能直接访问数据，Channel只能与Buffer进行交互。通道主要用于传输数据，从缓冲区的一侧传到另一侧的实体（如文件、套接字…），反之亦然；通道是访问IO服务的导管，通过通道，我们可以以最小的开销来访问操作系统的I/O服务；顺便说
Java网络编程——NIO三大组件Buffer、Channel、Selector
点滴汇聚，智在积累。——Danny
08-03 1173
Java NIO（Java Non-Blocking IO）也就是非阻塞IO，说是非阻塞IO，其实NIO也支持阻塞IO模型（默认就是），相对于BIO来说，NIO最大的特点是支持IO多路复用模式，可以通过一个线程监控多个IO流(Socket)的状态，来同时管理多个客户端，极大提高了服务器的吞吐能力。在NIO中有3个比较重要的组件：Buffer、Channel、Selector。......
网络编程方面针对selecto和channel的感悟
weixin_30703911的博客
11-01 174
　　今天突发奇想写了一下selector和socketChannel的几行代码，对channel和selector有了一些比较有意思的理解。 其实今天感悟的是selector解决的根本性问题，解决的是网络程序的连接数量问题，在没有出现这个技术之前，一个连接需要有一个线程维持连接，占用资源多，连接越多，开启的线程越多。 而使用selector却可以使用一个线程来维持很多连接，减轻了操作系统的线程...
I/O之内核buffer-“buffer cache”
鱼思故渊的专栏
03-18 1831
"buffercache" 要理解"buffercache"这个东西，需要澄清一下概念： 一般情况下，进程在io的时候，要依赖于内核中的一个buffer模块来和外存发生数据交换行为。另一个角度来说，数据从应用进程自己的buffer流动到外存，中间要先拷贝到内核的buffer中，然后再由内核决定什么时候把这些载有数据的内核buffer写出到外存。 "buffer cache"仅仅被内核用于常
网络协议-BIO实战和NIO编程
weixin_43874650的博客
12-23 790
flip 方法将 Buffer 从写模式切换到读模式。调用 flip0)方法会将 position 设回 0,并将 limit设置成之前 position 的值。put 方法有很多版本，允许你以不同的方式把数据写入到 Buffer 中。例如， 写到一个指定的位置，或者把一个字节数组写入到 Buffer。put(byte b) 相对写，向 position 的位置写入一个 byte，并将 postion+1，为下次读写作准备。从 Channel 写到 Buffer 的例子。原生JDK网络编程-BIO。
Netty学习笔记（二）java NIO Buffer、Channel、Selector学习及使用，搭建nio群聊系统
yangwen-bo的博客
09-15 236
缓冲区（Buffer） 缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。 Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer。 在NIO中，Buffer是一个顶级父类，它是一个抽象类，类的层级关系如图：（每个buffer实现类中都有对应数据类型的数组用来存储数据（所以buffer实际上数据是存在该数组中的）
学Netty前，还是要先把JavaNIO编程模型掌握好
wdjnb的博客
05-13 375
一、Java NIO 基本介绍 Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的 NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。 NIO是面向缓冲区 ，或者面向 快 编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使
Zephyr OS 中的简化版网络 Buffer
乐吧的博客
03-08 659
本文介绍 Zephyr OS 中的简化版网络 Buffer。转自：https://github.com/tidyjiang8/zephyr-inside/blob/old/src/net/common/simply-buf.md引言缓冲池(Buffer Pool)是 Zephyr OS 中的两个协议栈 uIP 和 yaip 所共用的数据结构。缓冲池分为两类，分别是简化版 Buffer 和完整版 Bu
MySQL中Buffer pool、Log Buffer和redo、undo日志介绍
最新发布
qq_44373419的博客
03-21 1569
一个简单的做法 ：在事务提交完成之前把该事务所修改的所有页面都刷新到磁盘，但是这个简单粗暴的做法有些问题另一个解决的思路 ：我们只是想让已经提交了的事务对数据库中数据所做的修改永久生效，即使后来系统崩溃，在重启后也能把这种修改恢复出来。redo log的写入并不是直接写入磁盘的，InnoDB引擎会在写redo log的时候先写redo log buffer，之后以 一定的频率 刷入到真正的redo log file 中。所有的变更都必须先更新缓冲池中的数据，然后缓冲池中的脏页会以一定的频率被刷入磁盘中。
MySQL基础篇 上
qq_45861183的博客
05-09 146
一条SQL查询语句是如何执行的 先看下面的MySQL基本架构示意图，你可以清楚的看到SQL语句在各个功能模块的中的执行过程。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mP2o2hRf-1620522157044)(C:\Users\Administrator\Desktop\markImg\image-20210507092744434.png)] 大体来说，MySQL分为Server层和存储引擎层两部分，不同的存储引擎共用一个Server层。 Server层包括连接器
InnoDB存储引擎——redo log
MuskMelon
01-27 358
redo log 作用 事务有一个重要特性：持久性，意思是说，只要事务提交成功，那么对数据库的修改就被永久保存了下来。怎么来保证持久性呢？ 简单的做法是在每次事务提交的时候，将该事务涉及到的数据页全刷回磁盘，但是这么做会导致严重的性能问题，主要体现在以下两点： InnoDB 中是以页为单位进行磁盘IO的，一个事务的修改可能只是修改数据页里的几个字节，这时候将整个数据页全部刷磁盘的话，太浪费资源了 一个事务的修改可能涉及多个数据页，并且这些数据页在物理上并不连续，使用随机IO写入性能差 为了解决这些问题，
mysql详解之innoDB
yunduanyou的博客
02-18 971
mysql innodb
Linux中Buffer和Cache的区别
热门推荐
上善若水，水善利万物而不争。
11-22 2万+
今天监控linux资源时，在输入top命令后，发现内存相关MEM和SWAP的buffer与Cache，顺便研究了一下。什么是Cache?什么是Buffer?二者的区别是什么？ Buffer和Cache的区别 buffer与cache操作的对象就不一样。1、buffer（缓冲）是为了提高内存和硬盘（或其他I/O设备）之间的数据交换的速度而设计的。2、cache（缓存）a）从CPU角度考虑，是为了提高...
每天3分钟操作系统修炼秘籍（13）：两个缓冲空间Kernel Buffer和IO Buffer
山有山的高度，海有海的胸怀。
11-16 496
点我查看秘籍连载 两个缓冲空间：kernel buffer和io buffer 先看一张图，稍后将围绕这张图展开描述。图中的fd table、open file table以及两个inode table都可以不用理解，只需要知道它们体现出来的文件描述符和磁盘文件之间的对应关系：文件描述符fd（例如图中的fd=3）是对应磁盘上文件的。 在Linux下，我们经常会在IO操作时不可避免的涉及到文...
操作系统中的缓冲（buffer）
tkp2014的专栏
07-13 2852
缓冲最常见于IO系统，例如：当希望向屏幕输出数据的时候，由于程序逻辑的关系，可能要多次调用printf函数，每次写入的数据只有几个字符，如果每次写数据都要 进行一次系统调用，让内核向屏幕写数据，这样效率很低下。因为系统调用的开销很大，它要进行上下文切换、内核参数检查、复制等，如果频繁进行系统调用，会严重影响程序和系统性能。 一种可行的方案是：对控制台连续的多次写入放在一个数组里，等到数
MySQL：redo log buffer
OceanStar的博客
12-22 1974
什么是redo log buffer 我们平时执行完增删改之后，要写入磁盘的redo log，其实应该是先进入redo log block这个数据结构里去的，然后在进入磁盘文件里： 也就是说redo log先通过内存缓存之后，再进入到磁盘文件里去的。这里涉及到了一个新的组件，redo log buffer，它是MySQL专门涉及用来缓存redo log写入的。 这个redo log buffer其实就是MySQL在启动的时候，跟操作系统申请的一块连续内存空间，和buffer pool（申请之后划分了N个空
NIO编程基础知识：Channel、Buffer和Selector
Nio中有两个核心组件：Channel和Buffer。 Channel Channel是Nio中的一种基本组件，用于读取和写入数据。Channel有多种实现，例如： * FileChannel：从文件中读写数据。 * DatagramChannel：通过UDP读写网络中数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Survivor001

你可以相信我,如果你愿意的话

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值