bm-site

Appearance

Netty中无锁串行化是怎么设计的 ​

Netty 的无锁串行化设计是其高性能和高并发处理能力的核心之一。无锁串行化设计的主要思想是每条连接对应一个独立的 ChannelPipeline，每个 ChannelPipeline 在特定的 EventLoop 中运行，该 EventLoop 在单一线程中处理所有事件。这种设计避免了多线程竞争和锁的开销，从而提高了系统的吞吐量和响应性能。

无锁串行化设计的核心 ​

  1. 每个 Channel 绑定到一个特定的 EventLoop: 事件循环负责处理该 Channel 的所有事件（如读、写、连接等），确保同一个 Channel 的操作总是在同一个线程中执行。
  2. 事件队列: EventLoop 拥有一个事件队列，将所有事件提交到该队列中进行处理。
  3. 任务调度: EventLoop 的单线程模型会依次处理事件队列中的任务，从而避免了多线程竞争。

这种模型下，由于每个 Channel 的操作在其事件循环（单线程）中串行化执行，消除了多线程操作同一资源所需的锁和同步机制，降低了并发处理的复杂性。

代码示例 ​

下面的代码展示了 Netty 的无锁串行化设计的基本思路：

plain
import io.netty.bootstrap.ServerBootstrap;  
import io.netty.channel.ChannelInitializer;  
import io.netty.channel.ChannelOption;  
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 NettyServer {  
    public static void main(String[] args) throws Exception {  
        // 创建事件循环组  
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // boss 线程组，用于接受连接  
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // worker 线程组，用于处理读写操作  

        try {  
            // 创建服务器启动类  
            ServerBootstrap b = new ServerBootstrap();  
            b.group(bossGroup, workerGroup)  
                    .channel(NioServerSocketChannel.class)  
                    .option(ChannelOption.SO_BACKLOG, 128)  
                    .childOption(ChannelOption.SO_KEEPALIVE, true)  
                    .childHandler(new ChannelInitializer<SocketChannel>() {  
                        @Override  
                        protected void initChannel(SocketChannel ch) throws Exception {  
                            // 为每个已接受的连接创建一个新的 ChannelPipeline  
                            ch.pipeline().addLast(new MyChannelHandler());  
                        }  
                    });  

            // 绑定端口，开始接收连接  
            b.bind(8080).sync().channel().closeFuture().sync();  
        } finally {  
            // 优雅地关闭事件循环组  
            workerGroup.shutdownGracefully();  
            bossGroup.shutdownGracefully();  
        }  
    }  
}  

class MyChannelHandler extends io.netty.channel.ChannelInboundHandlerAdapter {  
    @Override  
    public void channelRead(io.netty.channel.ChannelHandlerContext ctx, Object msg) throws Exception {  
        // 这里的操作在同一个 EventLoop 的同一个线程中执行，保证了无锁串行化  
        System.out.println("Received message: " + msg);  
        ctx.writeAndFlush(msg);  
    }  

    @Override  
    public void exceptionCaught(io.netty.channel.ChannelHandlerContext ctx, Throwable cause) throws Exception {  
        cause.printStackTrace();  
        ctx.close();  
    }  
}

关键点解释 ​

  1. 事件循环组 (EventLoopGroup): 包含多个 EventLoop，每个 EventLoop 负责处理多个 Channel 的 I/O 操作，但一个 Channel 只会被一个 EventLoop 处理。 NioEventLoopGroup 是其实现，用于处理基于 NIO 的 Channel。
  2. ChannelPipeline 和 ChannelHandler: initChannel 方法为每个新接入的连接（Channel）创建一个 ChannelPipeline，并将 MyChannelHandler 加入其中。MyChannelHandler 中的操作将在同一个线程（同一个 EventLoop）中执行，确保了无锁串行化。
  3. 无锁串行化的实现: 由于 Netty 确保了每个 Channel 的所有 I/O 操作都由同一个 EventLoop 处理，并且是串行执行的，因此不需要使用锁机制来保证线程安全。

这种设计极大地简化了并发编程的复杂性，在高并发环境下提升了系统的性能和可扩展性。

更新: 2024-08-05 20:39:08
原文: https://www.yuque.com/tulingzhouyu/db22bv/annknow3d9saprw9