美文网首页
Netty-理解selector是什么

Netty-理解selector是什么

作者: pq217 | 来源:发表于2022-05-25 18:31 被阅读0次

    BIO的弊端

    BIO既是Blocking IO,也叫同步阻塞模型,BIO模型如下

    BIO模型

    如果所示,多个客户端连接一个服务端, 每出现一个客户端就开一个handler(一般对应一个线程)处理

    对应的服务端代码如下

    public class BioServer {
    
        public static void main(String[] args) throws IOException {
            ServerSocket serverSocket = new ServerSocket(9000);
            // 任务处理线程池
            ExecutorService pool = Executors.newFixedThreadPool(10);
            while (true) {
                System.out.println("server start");
                //阻塞方法等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("new client");
                pool.execute(()->{
                    handler(clientSocket);
                });
            }
        }
    
        private static void handler(Socket clientSocket) {
            try {
                byte[] bytes = new byte[1024];
                System.out.println("reading");
                //接收客户端的数据,阻塞方法,没有数据可读时就阻塞
                int read = clientSocket.getInputStream().read(bytes);
                System.out.println("read over");
                if (read != -1) {
                    System.out.println("received data:" + new String(bytes, 0, read));
                }
                clientSocket.getOutputStream().write("HelloClient".getBytes());
                clientSocket.getOutputStream().flush();
            } catch (Exception e) {
    
            }
        }
    }
    

    上面的代码使用了线程池来处理客户端业务,整个代码有两步阻塞

    • 一步主线程阻塞等待客户端连接
    • 一步线程池的线程阻塞等待客户端传输数据准备好

    其实第一步阻塞到没什么,作为一个服务没有客户的情况下不阻塞也无事可做,主要是第二个阻塞,上面代码线程池size是10,假如当前有10个客户端连接都不发送数据,那么10个线程都阻塞,此时再来一个客户端发送完数据也无法及时处理

    假设现在有个澡堂子,一共雇佣10个搓澡工,BIO就好比来一个客人就分配一个搓澡师傅,这个师傅就死死盯着客人洗澡,啥时候洗澡完了就开始安排搓澡,如果十个客户在池子里洗澡洗不完,这时有11号客户来了,没有空闲的搓澡师傅(都在等待客户洗完澡),那这个客户只能傻傻的等着,实际上十个搓澡工都没有实际干活,但却处于傻傻的等待不可用状态

    解决思路

    通过上面的例子可以看出,BIO的模型明显是反人类的,合理的工作流程是这样

    10个搓澡师傅都待着,什么时候有人洗完澡了才分配搓澡师傅进行搓澡,这样搓澡师傅的工作更加合理,充分的压榨了搓澡师傅

    客户只会因为搓澡师傅都在搓澡而等待,而不是因为搓澡师傅都在傻等而等待

    这样设计显然更加合理,也更加符合现实的工作流程,相当于事件驱动,当发生洗完澡(接收到数据)事件后,再安排搓澡工(线程)进行处理

    回到代码怎么才能做到以事件驱动呐?更确切的说,作为java代码,如何得知数据传输的事件发生呐?

    显然java本身肯定是做不到的,我们可以想一下数据的来源,一个网络数据的传输,一台机器通过网线或无线等形式发送二进制数据到一台电脑,硬件的驱动必然能感知到,那么操作系统也一定能感知到,所以一个链接是否有数据传输,操作系统最知道!

    epoll

    linux 提供了epoll系列函数

    man epoll

    上层代码可以通过调用该系列函数订阅感兴趣的事件,后续即可感知到注册事件的发生,主要方法如下

    • epoll_create: 创建一个epoll实例
    • epoll_ctl: 订阅事件
    • epoll_wait: 阻塞等待订阅事件的发生

    有个这系列函数,java代码就可以:

    • 调用epoll_create创建一个epoll实例
    • 调用epoll_ctl订阅可读事件(相当于有数据传输事件)
    • 调用epoll_wait阻塞并等待时间发生

    当然不能直接调用,而是调用底层C++再调用linux函数

    NIO

    有了操作系统的支持,java就可以实现一个不阻塞的IO服务,这就是NIO模型(Non Blocking IO)

    JDK1.4开始引入java.nio包,在linux系统中底层就是使用epoll实现的(windows中基于winsock2,不开源)

    先看一下NIO实现服务的代码

    public class NioServer {
    
        public static void main(String[] args) throws IOException, InterruptedException {
    
            // 创建NIO ServerSocketChannel
            ServerSocketChannel serverSocket = ServerSocketChannel.open();
            serverSocket.socket().bind(new InetSocketAddress(9000));
            serverSocket.configureBlocking(false);
            // 打开Selector处理Channel,底层调用epoll_create
            Selector selector = Selector.open();
            // 把ServerSocketChannel注册到selector上,并且selector对客户端accept连接操作感兴趣,底层调用epoll_ctl
            serverSocket.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务启动成功");
    
            while (true) {
                // 阻塞等待需要处理的事件发生,即调用epoll_wait
                selector.select();
    
                // 获取selector中注册的全部事件的 SelectionKey 实例
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
    
                // 遍历SelectionKey对事件进行处理
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    // 如果是OP_ACCEPT事件,则进行连接获取和事件注册
                    if (key.isAcceptable()) {
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        SocketChannel socketChannel = server.accept();
                        socketChannel.configureBlocking(false);
                        // 这里只注册了读事件,如果需要给客户端发送数据可以注册写事件,底层调用epoll_ctl
                        socketChannel.register(selector, SelectionKey.OP_READ);
                        System.out.println("客户端连接成功");
                    } else if (key.isReadable()) {  // 如果是OP_READ事件,则进行读取和打印
                        SocketChannel socketChannel = (SocketChannel) key.channel();
                        ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                        int len = socketChannel.read(byteBuffer);
                        // 如果有数据,把数据打印出来
                        if (len > 0) {
                            System.out.println("接收到消息:" + new String(byteBuffer.array()));
                        } else if (len == -1) { // 如果客户端断开连接,关闭Socket
                            System.out.println("客户端断开连接");
                            socketChannel.close();
                        }
                    }
                    //从事件集合里删除本次处理的key,防止下次select重复处理
                    iterator.remove();
                }
            }
        }
    }
    

    上面及是一个典型的NIO代码,其中(liunx中):

    • Selector.open() 底层调用liunx的epoll_create
    • socketChannel.register(selector, SelectionKey.OP_READ)相当于调用liunx的epoll_ctl(实际上只是缓存起来,下一步再真正执行epoll_ctl)
    • selector.select() 底层调用epoll_wait,阻塞并等待订阅事件发生

    总结

    selector 是java.nio包中一个nio解决方案,主要可以实现

    • 订阅IO事件,如连接事件和有数据传输事件
    • 阻塞并等待任何订阅事件的发生

    在linux内核中,selector就是对epoll函数的一种封装,或者说epoll是linux针对java selector的实现

    相关文章

      网友评论

          本文标题:Netty-理解selector是什么

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