RPC框架设计二、NIO编程

关兮月

已于 2024-06-09 23:29:54 修改

阅读量995

点赞数 20

分类专栏：分布式架构设计&微服务深入剖析文章标签： rpc nio 网络协议

于 2024-06-09 22:15:14 首次发布

本文链接：https://blog.csdn.net/qq_43626215/article/details/139567062

版权

分布式架构设计&微服务深入剖析专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1.NIO介绍

Java NIO全称Java non-blocking IO，是指JDK提供的新API。从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO（即New IO），是同步非阻塞的。

NIO有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器）
NIO是是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络
Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有1万个请求过来，根据实际情况，可以分配50或100个线程来处理。不像之前的阻塞IO那样，非得分配1万个。

2.NIO和BIO的比较

BIO以流的方式处理数据，而NIO以缓冲区的方式处理数据，缓冲区I/O的效率比流I/O高很多
BIO是阻塞的，NIO则是非阻塞的
BIO基于字节流和字符流进行操作，而NIO基于Channel（通道）和Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。

3.NIO三大核心原理示意图

一张图描述NIO的Selector、Channel和Buffer的关系

每个Channel都会对应一个Buffer
Selector对应一个线程，一个线程对应多个Channel（连接）
每个Channel都注册到Selector选择器上
Selector不断轮询查看Channel上的事件，事件是通道Channel非常重要的概念
Selector会根据不同的事件，完成不同的处理操作
Buffer就是一个内存块，底层是有一个数组
数据的读取写入是通过Buffer，这个和BIO不同，BIO中要么是输入流，或者输出流，不能双向，但是NIO的Buffer是可以读也可以写，Channel是双向的

4.缓冲区（BUffer）

1）基本介绍

缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个数组，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel提供从网络读取数据的渠道，但是读取或写入的数据都必须经由Buffer。

2）Buffer常用API介绍

(1).Buffer类及其子类

在NIO中，Buffer是一个顶层父类，它是一个抽象类，类的层级关系图，常用的缓冲区分别对应byte、short、int、long、float、double、char 7种。

(2)缓冲区对象创建

方法名	说明
static ByteBuffer allocate(长度)	创建byte类型的指定长度的缓冲区
static ByteBuffer wrap(byte[] array)	创建一个有内容的byte类型缓冲区

public class CreateBufferDemo {

    public static void main(String[] args) {
        //1.创建指定长度的缓冲区 ByteBuffer为例
        ByteBuffer allocate = ByteBuffer.allocate(5);
        for (int i = 0; i < 5; i++) {
            System.out.println(allocate.get());//冲缓冲区中拿取数据
        }

        //2.创建一个有内容感到缓冲区
        ByteBuffer wrap = ByteBuffer.wrap("xiaoguan".getBytes());
        for (int i = 0; i < 8; i++) {
            System.out.println(wrap.get());
        }
    }
}

(3)缓冲区对象添加数据

方法名	说明
int position()/position(int newPosition)	获得当前操作的索引/修改当前要操作的索引位置
int limit()/limit (int newLimit)	最多能操作到哪个索引/修改最多能操作的索引位置
int capacity()	返回缓冲区的总长度
int remaining()/bollean hasRemaining()	还有多少操作索引个数/是否还能操作
put(byte b)/put(byte[] src)	添加一个字节/添加字节数组

图解

public class PutBufferDemo {
    public static void main(String[] args) {
        //1.创建一个缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        System.out.println(allocate.position());//0 获取当前索引所在位置
        System.out.println(allocate.limit());//10 获取最多能操作哪个索引
        System.out.println(allocate.capacity());//10 获取缓冲区总长度
        System.out.println(allocate.remaining());//10 还有多少个可以操作的个数

        //修改当前索引所在位置
        allocate.position(1);
        //修改最多能操作到哪个索引的位置
        allocate.limit(9);
        System.out.println(allocate.position());//1 获取当前索引所在位置
        System.out.println(allocate.limit());//9 获取最多能操作哪个索引
        System.out.println(allocate.capacity());//10 获取缓冲区总长度
        System.out.println(allocate.remaining());//8 还有多少个可以操作的个数
        

        //如果缓冲区满了，可以调整position位置，就可以重复写，会覆盖之前存入索引位置的值
        allocate.position(0);
    }
}

(4)缓冲区对象读取数据

方法名	介绍
flip()	写切换读模式 limit设置position位置，position设置0
get()	读一个字节
get(byte[] dst)	读多个字节
get(int index)	读指定索引的字节
rewind()	将position设置为0，可以重复读
clear()	切换写模式，position设置为0，limit设置为capacity
array()	将缓冲区转换成字节数组返回

flip()方法图解：

clear()详解：

public class GetBufferDemo {
    public static void main(String[] args) {
        //1.创建一个指定长度的缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        allocate.put("0123".getBytes());

        //切换读模式
        allocate.flip();
        for (int i = 0; i < allocate.limit(); i++) {
            System.out.println(allocate.get());
        }

        //切换写模式，覆盖之前索引所在位置的值
        allocate.clear();
        allocate.put("abc".getBytes());
    }
}

【注】

capacity：容量（长度）limit：界限（最多能读/写到哪里）position：位置（读/写哪个索引）
获取缓冲区里面数据之前，需要调用flip方法
再次写数据之前，需要调用clear方法，但是数据还未小时，等再次写入数据，被覆盖了才会消失

5.通道（Channel）

1）基本介绍

通常来说NIO中的所有IO都是从Channel（通道）开始的。NIO的通道类似于流，但有些区别如下：

通道可以读也可以写，流一般来说是单向的（只能读或者写，所以之前我们用流进行IO操作的时候需要分别创建一个输入流和一个输出流）
通道可以异步读写
通道总是基于缓冲区Buffer来读写

2）Channel常用类介绍

Channel接口：
常用的Channel实现类有：

FileChannel，用于文件的数据读写
DatagramChannel，用于UDP的数据读写
ServerSocketChannel，用于TCP的数据读写，类似ServerSocket
SocketChannel,用于TCP的数据读写，类似Socket

3）ServerSocketChannel

打开一个服务端通道
绑定对应的端口号
通道默认是阻塞的，需要设置为非阻塞
检查是否有客户端连接，有客户端连接会返回对应的通道
获取客户端传递过来的数据，并把数据放在ByteBuffer这个缓冲区中
给客户端回写数据
释放资源

public class NIOServer {

    public static void main(String[] args) throws IOException, InterruptedException {
        //1. 打开一个服务端通道
        ServerSocketChannel channel = ServerSocketChannel.open();
        //2. 绑定对应的端口号
        channel.bind(new InetSocketAddress(9999));
        //3. 通道默认是阻塞的，需要设置为非阻塞
        channel.configureBlocking(false);
        System.out.println("服务端启动成功");
        while (true){
            //4. 检查是否有客户端连接，有客户端连接会返回对应的通道
            SocketChannel socketChannel = channel.accept();
            if (socketChannel == null){
                System.out.println("没有客户端连接，可以去做别的事情");
                Thread.sleep(1000);
                continue;
            }
            //5. 获取客户端传递过来的数据，并把数据放在ByteBuffer这个缓冲区中
            ByteBuffer allocate = ByteBuffer.allocate(1024);
            //返回值
            //正数: 表示本次读到有效字节数
            //0: 表示本次没有读到数据
            //-1: 表示读到末尾
            int read = socketChannel.read(allocate);
            System.out.println("客户端消息:"+new String(allocate.array(),0,read, StandardCharsets.UTF_8));
            //6. 给客户端回写数据
            socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
            //7. 释放资源
            socketChannel.close();

        }
    }
}

4）SocketChannel

打开通道
设置连接IP和端口号
写出数据
读取服务器写回的数据
释放资源

public class NIOClient {

    public static void main(String[] args) throws IOException {
        //1. 打开通道
        SocketChannel socketChannel = SocketChannel.open();
        //2. 设置连接IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
        //3. 写出数据
        socketChannel.write(ByteBuffer.wrap("老板还钱吧！".getBytes(StandardCharsets.UTF_8)));
        //4. 读取服务器写回的数据
        ByteBuffer allocate = ByteBuffer.allocate(1024);
        int read = socketChannel.read(allocate);
        System.out.println("服务端消息:"+new String(allocate.array(),0,read,StandardCharsets.UTF_8));
        //5. 释放资源
        socketChannel.close();
    }
}

6.选择器（Selector）

1）基本介绍

可以用一个线程，处理多个的客户端连接，就会使用到NIO的Selector（选择器），Selector能够检测多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

在这种没有选择器的情况下，每个连接对应一个处理线程，但是连接并不能马上就会发送消息，所以还会产生资源浪费。

只有在通道真正有读写事件发生时，才会进行读写，就大大较少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，避免了多线程之间的上下文切换导致的开销。

2）常用API介绍

Selector类是一个抽象类
常用方法：

方法	作用
Selector.open()	得到一个选择器对象
Selector.select()	阻塞，监控所有注册的通道，当有对应的事件操作时，会将SelectionKey放入集合内部并返回事件数量
Selector.select(1000)	阻塞 1000毫秒，监控所有注册的通道，当有对应的事件操作时，会将SelectionKey放入集合内部并返回
Selector.selectedKey(s)	返回存有SelectionKey的集合

SelectionKey，事件
常用方法

方法	作用
SelectionKey.isAcceptable()	是否是连接继续事件
SelectionKey.isConnectable()	是否是连接就绪事件
SelectionKey.isReadable()	是否是读就绪事件
SelectionKey.isWritable()	是否是写就绪事件

SelectionKey中定义的4中事件

SelectionKey.OP_ACCEPT	接受连续继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
SelectionKey.OP_CONNECT	连接就绪事件，表示客户与服务器的连接已经建立成功
SelectionKey.OP_READ	读就绪事件，表示通道中已经有了可读的数据，可以指定读操作了（通道目前有数据，可以进行读操作了）
SelectionKey.OP_WRITE	写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）

在这种没有选择器的情况下，每个连接对应一个处理线程，但是连接并不能马上就会发送消息，所以还会产生资源浪费。

只有在通道真正有读写事件发生时，才会进行读写，就大大较少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，避免了多线程之间的上下文切换导致的开销。

3）Selector编码

打开一个服务端通道
绑定对应的端口号
通道默认是阻塞的，需要设置为非阻塞
创建选择器
将服务端通道注册到选择器上，并指定注册监听的事件为OP_ACCEPT
检查选择器是否有事件
获取事件集合
判断事件是否是客户端连接事件 SelectionKey.isAcceptable()
得到客户端通道，并将通道注册到选择器上，并指定监听事件为OP_READ
判断是否是客户端读就绪事件SelectionKey.isReadable()
得到客户端通道，读取数据到缓冲区
给客户端回写数据
从集合中删除对应的事件，防止二次处理

public class NIOSelectorServer {

    public static void main(String[] args) throws IOException {
        //1. 打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2. 绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //3. 通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //4. 创建选择器
        Selector selector = Selector.open();
        //5. 将服务端通道注册到选择器上，并指定注册监听的事件为OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务端启动成功");
        while (true){
            //6. 检查选择器是否有事件
            int select = selector.select(2000);
            if (select == 0){
                System.out.println("没有事件发生");
                continue;
            }
            //7. 获取事件集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()){
                //8. 判断事件是否是客户端连接事件 SelectionKey.isAcceptable()
                SelectionKey key = iterator.next();
                if (key.isAcceptable()){
                    //9. 得到客户端通道，并将通道注册到选择器上，并指定监听事件为OP_READ
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("有客户端连接");
                    //必须将通道设置为非阻塞状态，因为selector选择器需要轮询监听每个通道的事件
                    socketChannel.configureBlocking(false);
                    //指定监听事件为OP_READ 读就绪事件
                    socketChannel.register(selector,SelectionKey.OP_READ);
                }
                //10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
                if (key.isReadable()){
                    //11. 得到客户端通道，读取数据到缓冲区
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer allocate = ByteBuffer.allocate(1024);
                    int read = socketChannel.read(allocate);
                    if (read>0){
                        System.out.println("客户端消息:"+new String(allocate.array(),0,read, StandardCharsets.UTF_8));
                        //12. 给客户端回写数据
                        socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
                        socketChannel.close();
                    }
                }
                //13. 从集合中删除对应的事件，防止二次处理
                iterator.remove();

            }
        }
    }
}

关兮月

关注

20
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
RPC框架设计二、NIO编程

Java NIO全称Java non-blocking IO，是指JDK提供的新API。从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO（即New IO），是同步非阻塞的。NIO有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器）NIO是是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。
复制链接

扫一扫