目录
Netty是一个基于NIO（非阻塞I/O）的客户端-服务器框架，它使用Reactor模式来实现高并发处理。Netty的线程模型是其高性能、高并发处理能力的重要支撑。以下是Netty的三种主要线程模型及其特点的详细介绍：
一、单线程模型（单Reactor单线程）
-
特点：EventLoopGroup只包含一个EventLoop，Boss和Worker使用同一个EventLoopGroup。
-
工作原理：一个线程需要执行处理所有的accept、read、decode、process、encode、send事件。
-
优点：
- 不需要上下文切换。
- 不存在线程安全的问题。
-
缺点：
- 只有一个线程处理，无法发挥CPU多核的效率。
- 如果请求比较多的情况下，容易遇到性能瓶颈。
- 如果线程因某种意外原因终止，会导致整个系统模块无法使用。
-
适用场景：客户端连接数量有一定限制，且业务处理时间非常快的场景。
-
举例：
EventLoopGroup group = new NioEventLoopGroup(1); // 创建一个只有1个线程的EventLoopGroup
try {
ServerBootstrap b = new ServerBootstrap();
b.group(group)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
// 设置ChannelPipeline中的处理器
ch.pipeline().addLast(new YourServerHandler());
}
});
// 绑定端口并启动服务器
ChannelFuture f = b.bind(8080).sync();
// 等待服务器关闭
f.channel().closeFuture().sync();
} finally {
// 优雅关闭EventLoopGroup
group.shutdownGracefully();
}// 假设有一个单线程的Reactor，负责监听、接收连接、读写操作
class SingleThreadReactor {
EventLoop eventLoop; // 单个事件循环线程
SingleThreadReactor() {
eventLoop = new EventLoop(); // 初始化单个事件循环
}
void start(int port) {
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.socket().bind(new InetSocketAddress(port)); // 绑定端口
eventLoop.execute(() -> { // 在事件循环中执行
while (true) {
SocketChannel clientSocket = serverSocket.accept(); // 接受连接
if (clientSocket != null) {
handleConnection(clientSocket); // 处理连接
}
}
});
eventLoop.run(); // 启动事件循环
}
void handleConnection(SocketChannel clientSocket) {
// 读写操作，这里简化处理
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (clientSocket.read(buffer) > 0) {
// 处理读取的数据
buffer.flip();
// 假设处理数据逻辑...
buffer.clear();
}
// 写操作逻辑类似
}
}二、多线程模型（单Reactor多线程）
-
特点：EventLoopGroup包含多个EventLoop，但Boss和Worker仍然使用同一个EventLoopGroup。
-
工作原理：一个Acceptor线程只负责监听客户端的连接，而一个NIO线程池则负责具体处理accept、read、decode等事件。这里的Worker线程实际上是在线程池中执行的。
-
优点：
- 相比单线程模型，能更好地利用多核CPU资源。
- 提高系统的吞吐量和并发处理能力。
-
缺点：
- 如果某个EventLoop的线程负载过重，可能会影响整个系统的性能。
-
适用场景：适用于连接数量较多，但业务处理相对简单，且不需要过多线程间交互的场景。
-
举例：
EventLoopGroup bossGroup = new NioEventLoopGroup(1); // Boss线程组，通常只需要一个线程
EventLoopGroup workerGroup = new NioEventLoopGroup(); // Worker线程组，线程数量可以根据需要配置
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
// 设置ChannelPipeline中的处理器
ch.pipeline().addLast(new YourServerHandler());
}
})
.option(ChannelOption.SO_BACKLOG, 128) // 设置用于临时存放已完成三次握手连接的队列长度
.childOption(ChannelOption.SO_KEEPALIVE, true); // 设置保持长连接
// 绑定端口并启动服务器
ChannelFuture f = b.bind(8080).sync();
// 等待服务器关闭
f.channel().closeFuture().sync();
} finally {
// 优雅关闭EventLoopGroup
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}// 假设有两个线程，一个用于监听连接，一个用于处理连接后的操作
class MultiThreadReactor {
EventLoop acceptLoop;
EventLoop workerLoop;
MultiThreadReactor() {
acceptLoop = new EventLoop(); // 接收连接的线程
workerLoop = new EventLoop(); // 处理连接的线程
}
void start(int port) {
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.socket().bind(new InetSocketAddress(port));
acceptLoop.execute(() -> { // 在接受线程中监听
while (true) {
SocketChannel clientSocket = serverSocket.accept();
if (clientSocket != null) {
workerLoop.execute(() -> handleConnection(clientSocket)); // 将新连接交给工作线程处理
}
}
});
acceptLoop.run(); // 启动接受线程
workerLoop.run(); // 启动工作线程
}
// handleConnection 方法与单线程模型中的相同
}三、主从多线程模型（主从Reactor多线程）
-
特点：EventLoopGroup包含多个EventLoop，但Boss和Worker分别使用不同的EventLoopGroup。其中，Boss作为主Reactor，负责新的网络连接Channel的创建，并将Channel注册到从Reactor（即Worker）中。
-
工作原理：
- 主Reactor（Boss）负责监听和接受新的客户端连接。
- 当有新的连接到来时，主Reactor将其注册到从Reactor（Worker）中。
- 从Reactor负责具体的I/O操作，如读写数据等。
-
优点：
- 能够更好地处理高并发场景。
- 充分利用多核CPU资源。
- 减少线程间的竞争和冲突。
-
缺点：
- 实现复杂度较高。
- 需要合理配置主从Reactor的线程数量以达到最佳性能。
-
适用场景：适用于连接数量多、业务处理复杂、需要高并发处理能力的场景。
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
public class MainReactorModel {
public static void main(String[] args) {
// 主Reactor，用于接受连接
EventLoopGroup bossGroup = new NioEventLoopGroup();
// 从Reactor，用于处理连接后的读写操作
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
// 在这里添加业务处理器，如解码器、编码器、业务逻辑处理器
ch.pipeline().addLast(new MyBusinessHandler());
}
});
ChannelFuture future = bootstrap.bind(8080).sync();
System.out.println("Server started at port 8080");
future.channel().closeFuture().sync(); // 等待服务器关闭
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}在Netty中，可以通过配置EventLoopGroup的参数来选择不同的线程模型。例如，通过NioEventLoopGroup类的构造函数可以设置线程数量，从而控制EventLoop的数量。此外，Netty还提供了丰富的API和工具类，方便开发者根据自己的需求选择合适的线程模型，并对其进行优化和调整。
总的来说，Netty的线程模型设计得非常灵活和高效，能够根据不同的业务场景和需求进行定制和扩展。
总结：
- 单线程模型：一个
EventLoopGroup，一个线程。 - 多线程模型/主从多线程模型：两个
EventLoopGroup，一个用于Boss（通常一个线程），一个用于Worker（多个线程）。
在Netty的实践中，多线程模型和主从多线程模型之间的界限并不总是那么清晰，因为从Netty的角度来看，它们都是基于事件循环组的模型，只是角色分配和线程数量配置上的差异。
参考：
https://zhuanlan.zhihu.com/p/657824209
Netty, Nginx, Redis线程模型对比分析-百度开发者中心
https://zhuanlan.zhihu.com/p/539805602
扫一扫
866
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
