Netty EventLoopGroup 详解：Nio、Epoll、Poll 、KQueue和IoUring

Jack_hrx2024-07-02 21:36

Netty EventLoopGroup 详解：Nio、Epoll、Poll 、KQueue和IoUring

概述

Netty 是一个高性能的网络通信框架，它使用 EventLoopGroup 来处理 I/O 事件(学习更多请参考：深入探索Netty的事件驱动模型与实现原理)。不同的 EventLoopGroup 实现针对不同的操作系统和应用场景优化性能。本文详细介绍了 Netty 中的五种 EventLoopGroup 实现：NioEventLoopGroup、EpollEventLoopGroup、PollEventLoopGroup 、 KQueueEventLoopGroup 和 IoUringEventLoopGroup，并提供了详细的代码示例和注释。

1. NioEventLoopGroup

NioEventLoopGroup 是基于 Java NIO 的 EventLoopGroup 实现，适用于多平台环境。它通过 Java NIO 的 Selector 来实现非阻塞 I/O 操作。

原理解释

  • NIO: Java NIO 提供了异步 I/O 操作，通过 Selector 来实现非阻塞 I/O。Selector 允许一个线程监视多个通道的 I/O 事件，如连接、读取、写入。Selector 减少了线程切换的开销。

  • Selector: Selector 是 Java NIO 的核心组件之一。它允许一个线程监视多个 Channel，通过注册 Channel 和感兴趣的事件（如 OP_READ、OP_WRITE），Selector 能够在事件发生时进行处理。

  • 事件循环: NioEventLoopGroup 使用 Selector 处理 I/O 事件。每个 NioEventLoop 线程负责管理和处理一组 Channel 的 I/O 事件。

示例代码注解
sql 复制代码 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NioNettyServer {

    public static void main(String[] args) throws Exception {
        // 创建 NioEventLoopGroup 实例
        // bossGroup 负责接受客户端连接请求
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1); // 单线程用于接收连接请求
        // workerGroup 负责处理 I/O 操作
        NioEventLoopGroup workerGroup = new NioEventLoopGroup(); // 默认线程数，处理 I/O 事件

        try {
            // 创建 ServerBootstrap 实例
            ServerBootstrap bootstrap = new ServerBootstrap();
            
            // 配置服务器启动设置
            bootstrap.group(bossGroup, workerGroup) // 设置 bossGroup 和 workerGroup
                     .channel(NioServerSocketChannel.class) // 使用 NioServerSocketChannel，适用于 NIO
                     .childHandler(new ChannelInitializer<SocketChannel>() { // 设置 ChannelInitializer
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             // 配置 ChannelPipeline，处理数据的流水线
                             ChannelPipeline pipeline = ch.pipeline();
                             // 添加 StringDecoder 以将 ByteBuf 解码为 String
                             pipeline.addLast(new StringDecoder());
                             // 添加 StringEncoder 以将 String 编码为 ByteBuf
                             pipeline.addLast(new StringEncoder());
                             // 添加自定义的业务逻辑处理器
                             pipeline.addLast(new ServerHandler());
                         }
                     });

            // 绑定端口并启动服务器
            ChannelFuture future = bootstrap.bind(8080).sync(); // 绑定端口 8080 并等待绑定完成
            // 等待服务器关闭
            future.channel().closeFuture().sync(); // 等待服务器通道关闭
        } finally {
            // 优雅地关闭线程组
            bossGroup.shutdownGracefully(); // 关闭 bossGroup
            workerGroup.shutdownGracefully(); // 关闭 workerGroup
        }
    }
}

2. EpollEventLoopGroup

EpollEventLoopGroup 是基于 Linux 平台的 epoll 实现，专为高并发场景优化。

原理解释

  • epoll: epoll 是 Linux 提供的高效 I/O 多路复用机制，通过事件驱动的方式来处理大量并发连接。epoll 维护一个内核事件表来管理待处理的事件，减少了系统调用的开销。

  • 事件循环: EpollEventLoopGroup 使用 epoll 的 epoll_wait 系统调用来等待和处理 I/O 事件。它在 Linux 系统上提供了高性能的 I/O 处理能力。

示例代码注解
sql 复制代码 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollServerSocketChannel;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class EpollNettyServer {

    public static void main(String[] args) throws Exception {
        // 创建 EpollEventLoopGroup 实例
        // bossGroup 负责接受客户端连接请求
        EpollEventLoopGroup bossGroup = new EpollEventLoopGroup(1); // 单线程用于接收连接请求
        // workerGroup 负责处理 I/O 操作
        EpollEventLoopGroup workerGroup = new EpollEventLoopGroup(); // 默认线程数，处理 I/O 事件

        try {
            // 创建 ServerBootstrap 实例
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 配置服务器启动设置
            bootstrap.group(bossGroup, workerGroup) // 设置 bossGroup 和 workerGroup
                     .channel(EpollServerSocketChannel.class) // 使用 EpollServerSocketChannel 实现
                     .childHandler(new ChannelInitializer<SocketChannel>() { // 设置 ChannelInitializer
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             // 配置 ChannelPipeline，处理数据的流水线
                             ChannelPipeline pipeline = ch.pipeline();
                             // 添加 StringDecoder 以将 ByteBuf 解码为 String
                             pipeline.addLast(new StringDecoder());
                             // 添加 StringEncoder 以将 String 编码为 ByteBuf
                             pipeline.addLast(new StringEncoder());
                             // 添加自定义的业务逻辑处理器
                             pipeline.addLast(new ServerHandler());
                         }
                     });

            // 绑定端口并启动服务器
            ChannelFuture future = bootstrap.bind(8080).sync(); // 绑定端口 8080 并等待绑定完成
            // 等待服务器关闭
            future.channel().closeFuture().sync(); // 等待服务器通道关闭
        } finally {
            // 优雅地关闭线程组
            bossGroup.shutdownGracefully(); // 关闭 bossGroup
            workerGroup.shutdownGracefully(); // 关闭 workerGroup
        }
    }
}

3. PollEventLoopGroup

PollEventLoopGroup 是基于传统阻塞 I/O 实现的 EventLoopGroup，适合需要兼容旧系统的场景。

原理解释

  • poll: poll 是 Linux 和 Unix 系统提供的 I/O 多路复用机制，相比 select，poll 可以处理更多的文件描述符。它通过 pollfd 数组来检测多个文件描述符的状态。

  • 事件循环: PollEventLoopGroup 使用 poll 来处理 I/O 事件。与 epoll 和 NIO 相比，poll 在处理大量并发连接时性能较差，因为每次都需要遍历整个 pollfd 数组。

示例代码注解
sql 复制代码 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.oio.OioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.oio.OioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class PollNettyServer {

    public static void main(String[] args) throws Exception {
        // 创建 OioEventLoopGroup 实例
        // bossGroup 负责接受客户端连接请求
        OioEventLoopGroup bossGroup = new OioEventLoopGroup(1); // 单线程用于接收连接请求
        // workerGroup 负责处理 I/O 操作
        OioEventLoopGroup workerGroup = new OioEventLoopGroup(); // 默认线程数，处理 I/O 事件

        try {
            // 创建 ServerBootstrap 实例
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 配置服务器启动设置
            bootstrap.group(bossGroup, workerGroup) // 设置 bossGroup 和 workerGroup
                     .channel(OioServerSocketChannel.class) // 使用 OioServerSocketChannel 实现
                     .childHandler(new ChannelInitializer<SocketChannel>() { // 设置 ChannelInitializer
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             // 配置 ChannelPipeline，处理数据的流水线
                             ChannelPipeline pipeline = ch.pipeline();
                             // 添加 StringDecoder 以将 ByteBuf 解码为 String
                             pipeline.addLast(new StringDecoder());
                             // 添加 StringEncoder 以将 String 编码为 ByteBuf
                             pipeline.addLast(new StringEncoder());
                             // 添加自定义的业务逻辑处理器
                             pipeline.addLast(new ServerHandler());
                         }
                     });

            // 绑定端口并启动服务器
            ChannelFuture future = bootstrap.bind(8080).sync(); // 绑定端口 8080 并等待绑定完成
            // 等待服务器关闭
            future.channel().closeFuture().sync(); // 等待服务器通道关闭
        } finally {
            // 优雅地关闭线程组
            bossGroup.shutdownGracefully(); // 关闭 bossGroup
            workerGroup.shutdownGracefully(); // 关闭 workerGroup
        }
    }
}

4. KQueueEventLoopGroup

KQueueEventLoopGroup 是基于 macOS 和 BSD 系统的 kqueue 实现，提供高效的 I/O 操作。

原理解释

  • kqueue: kqueue 是 BSD 系统（包括 macOS）提供的高效 I/O 多路复用机制。它通过事件通知机制来处理 I/O 事件，与 epoll 类似。kqueue 提供了高效的事件通知，适用于 macOS 和 BSD 系统。

  • 事件循环: KQueueEventLoopGroup 使用 kqueue 的 kevent 系统调用来等待和处理 I/O 事件。kqueue 提供了高效的事件通知机制，适用于高并发场景。

示例代码注解
sql 复制代码 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.kqueue.KQueueEventLoopGroup;
import io.netty.channel.kqueue.KQueueServerSocketChannel;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class KQueueNettyServer {

    public static void main(String[] args) throws Exception {
        // 创建 KQueueEventLoopGroup 实例
        // bossGroup 负责接受客户端连接请求
        KQueueEventLoopGroup bossGroup = new KQueueEventLoopGroup(1); // 单线程用于接收连接请求
        // workerGroup 负责处理 I/O 操作
        KQueueEventLoopGroup workerGroup = new KQueueEventLoopGroup(); // 默认线程数，处理 I/O 事件

        try {
            // 创建 ServerBootstrap 实例
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 配置服务器启动设置
            bootstrap.group(bossGroup, workerGroup) // 设置 bossGroup 和 workerGroup
                     .channel(KQueueServerSocketChannel.class) // 使用 KQueueServerSocketChannel 实现
                     .childHandler(new ChannelInitializer<SocketChannel>() { // 设置 ChannelInitializer
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             // 配置 ChannelPipeline，处理数据的流水线
                             ChannelPipeline pipeline = ch.pipeline();
                             // 添加 StringDecoder 以将 ByteBuf 解码为 String
                             pipeline.addLast(new StringDecoder());
                             // 添加 StringEncoder 以将 String 编码为 ByteBuf
                             pipeline.addLast(new StringEncoder());
                             // 添加自定义的业务逻辑处理器
                             pipeline.addLast(new ServerHandler());
                         }
                     });

            // 绑定端口并启动服务器
            ChannelFuture future = bootstrap.bind(8080).sync(); // 绑定端口 8080 并等待绑定完成
            // 等待服务器关闭
            future.channel().closeFuture().sync(); // 等待服务器通道关闭
        } finally {
            // 优雅地关闭线程组
            bossGroup.shutdownGracefully(); // 关闭 bossGroup
            workerGroup.shutdownGracefully(); // 关闭 workerGroup
        }
    }
}

5. IoUringEventLoopGroup

IoUringEventLoopGroup 是基于 Linux 的 io_uring 实现，旨在提供更高效的异步 I/O 操作。

原理解释

  • io_uring: io_uring 是 Linux 内核 5.1 引入的一种高效的异步 I/O 提供机制。它通过环形缓冲区和内核与用户空间之间的高效通信来减少系统调用开销，提高 I/O 操作的效率。

  • 事件循环: IoUringEventLoopGroup 使用 io_uring 提供的接口来提交和完成 I/O 操作。它能够在高负载的场景下提供优异的性能，减少上下文切换和系统调用开销。

示例代码注解

sql 复制代码 
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.io_uring.IoUringEventLoopGroup;
import io.netty.channel.io_uring.IoUringServerSocketChannel;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class IoUringNettyServer {

    public static void main(String[] args) throws Exception {
        // 创建 IoUringEventLoopGroup 实例
        IoUringEventLoopGroup bossGroup = new IoUringEventLoopGroup(1); // 单线程用于接收连接请求
        IoUringEventLoopGroup workerGroup = new IoUringEventLoopGroup(); // 默认线程数，处理 I/O 事件

        try {
            // 创建 ServerBootstrap 实例
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                     .channel(IoUringServerSocketChannel.class)
                     .childHandler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             ChannelPipeline pipeline = ch.pipeline();
                             pipeline.addLast(new StringDecoder());
                             pipeline.addLast(new StringEncoder());
                             pipeline.addLast(new ServerHandler());
                         }
                     });

            // 绑定端口并启动服务器
            ChannelFuture future = bootstrap.bind(8080).sync();
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

性能比较

1. NioEventLoopGroup

适用平台: 跨平台（Windows、Linux、macOS 等）

优点:

  • 跨平台支持: 兼容多种操作系统，适用于大多数应用场景。
  • 内置于 Java NIO: 不需要额外的本地库，易于使用。
  • 良好的通用性: 提供了非阻塞 I/O 操作，适用于大多数网络应用。

缺点:

  • 性能不如专用机制: 在某些高并发场景下，性能可能不如 epoll 或 kqueue。
  • 资源开销: 对于高负载应用，可能需要更多的资源来处理 I/O 操作。

2. EpollEventLoopGroup

适用平台: Linux

优点:

  • 高性能: epoll 提供了高效的 I/O 多路复用，适合高并发场景。
  • 低延迟: 减少了系统调用的开销，提供了更低的 I/O 操作延迟。
  • 高吞吐量: 能够处理大量的并发连接和事件。

缺点:

  • Linux 专用: 仅适用于 Linux 平台，不支持其他操作系统。
  • 复杂性: 需要特定的内核支持，使用时需要关注系统的配置和限制。

3. PollEventLoopGroup

适用平台: 跨平台（但主要用于旧系统）

优点:

  • 兼容性强: 适用于较旧的系统和环境，提供了一定的向后兼容性。
  • 简单: 实现简单，易于理解和使用。

缺点:

  • 性能较差: 在高并发场景下，性能不如 epoll 和 kqueue，可能成为性能瓶颈。
  • 资源消耗: 对于大量的文件描述符，性能下降明显。

4. KQueueEventLoopGroup

适用平台: macOS 和 BSD 系统

优点:

  • 高性能: kqueue 提供了高效的 I/O 多路复用，适合高并发场景。
  • 低延迟: 减少了系统调用开销，提供了低延迟的 I/O 操作。
  • 专用优化: 适合 macOS 和 BSD 系统的特性。

缺点:

  • 平台限制: 仅适用于 macOS 和 BSD 系统，不支持其他操作系统。
  • 工具支持: 相较于其他机制，工具和文档支持可能较少。

5. IoUringEventLoopGroup

适用平台: Linux（内核 5.1 及以上）

优点:

  • 超高性能: io_uring 提供了极高的异步 I/O 性能，减少了系统调用开销。
  • 低延迟: 通过环形缓冲区和批量操作，显著降低了 I/O 操作的延迟。
  • 高吞吐量: 支持批量提交和处理 I/O 请求，适合高负载场景。

缺点:

  • 内核要求: 需要 Linux 内核 5.1 或更高版本，老旧系统不支持。
  • 学习曲线: API 较为复杂，开发者需要理解其操作方式。
  • 资源消耗: 在高负载情况下，可能会增加内存和 CPU 的使用。

选择合适的 EventLoopGroup 实现可以根据操作系统和应用场景优化网络应用的性能和可维护性。

相关推荐
钱多多_qdd8 分钟前
spring cache源码解析（四）——从@EnableCaching开始来阅读源码
java·spring boot·spring
waicsdn_haha10 分钟前
Java/JDK下载、安装及环境配置超详细教程【Windows10、macOS和Linux图文详解】
java·运维·服务器·开发语言·windows·后端·jdk
Q_192849990620 分钟前
基于Spring Boot的摄影器材租赁回收系统
java·spring boot·后端
Code_流苏22 分钟前
VSCode搭建Java开发环境 2024保姆级安装教程（Java环境搭建+VSCode安装+运行测试+背景图设置）
java·ide·vscode·搭建·java开发环境
禁默1 小时前
深入浅出：AWT的基本组件及其应用
java·开发语言·界面编程
Cachel wood1 小时前
python round四舍五入和decimal库精确四舍五入
java·linux·前端·数据库·vue.js·python·前端框架
Code哈哈笑1 小时前
【Java 学习】深度剖析Java多态：从向上转型到向下转型，解锁动态绑定的奥秘，让代码更优雅灵活
java·开发语言·学习
gb42152871 小时前
springboot中Jackson库和jsonpath库的区别和联系。
java·spring boot·后端
程序猿进阶1 小时前
深入解析 Spring WebFlux：原理与应用
java·开发语言·后端·spring·面试·架构·springboot
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10红米手机使用google play