The secrets of Netty network programming, just read this one

Netty

version: 4.1.55.Final

Traditional IO model web containers, such as the old version of Tomcat, need to continuously increase the number of system core threads or increase the system's request processing capacity by horizontally expanding the number of servers in order to increase system throughput. With NIO, one thread can handle multiple connection events. The Netty framework based on the multiplexing model not only reduces the complexity of using NIO,

advantage

Netty is a network application framework based on Java NIO and event-driven model that supports asynchronous and high concurrency

• The API is easy to use and has a low development threshold, which simplifies the complexity of developing network programs for NIO.
• It has powerful functions, preset multiple encoding and decoding functions, and supports multiple mainstream protocols, such as Http and WebSocket.
• It has strong customization capabilities and can flexibly expand the communication framework through ChannelHandler.
• High performance, supports asynchronous non-blocking communication model
• Mature and stable, with an active community, all Java NIO bugs have been fixed.
• It has been tested in large-scale commercial applications and its quality is guaranteed.

IO Model

select, poll, and epoll

The operating system kernel implements non-blocking IO based on these functions to implement a multiplexing model.

• select

select

1. The select call needs to pass in the fd array, which needs to be copied to the kernel. In high-concurrency scenarios, the resources consumed by such a copy are amazing. (It can be optimized to not copy)
2. Select still checks the readiness of file descriptors by traversing them at the kernel level. It is a synchronous process, but without the overhead of system call context switching. (The kernel level can be optimized to asynchronous event notification)
3. select only returns the number of readable file descriptors, and the user still needs to traverse which one is readable. (It can be optimized to only return the ready file descriptors to the user, without the user having to do invalid traversal)

• pool

The main difference from select is that the limitation of select that can only monitor 1024 file descriptors is removed.

• epool

epool

1. The kernel stores a set of file descriptors, so the user does not need to re-enter them each time. All they need to do is tell the kernel the modified parts.
2. The kernel no longer polls to find ready file descriptors, but is awakened by asynchronous IO events.
3. The kernel will only return the file descriptors with IO events to the user, and the user does not need to traverse the entire file descriptor set.

Reactor Model

1. Single Reactor Single Thread

1) It is possible to monitor multiple connection requests through a blocking object

2) The Reactor object listens to client request events through select and distributes them through dispatch

3) If it is a request to establish a connection, the Acceptor processes the connection request through accept, and then creates a Handler object to handle various events after the connection is completed

4) If it is not a link request, the Reactor will dispatch and call the corresponding Handler for the link to handle it

5) Handler will complete the complete business process of Read->Business Process->Send

2. Single Reactor Multithreading

1) The Reactor object listens to the client request event through select, and after receiving the event, it distributes it through dispatch

2) If it is a request to establish a connection, the Acceptor processes the connection request through accept, and then creates a Handler object to handle various events after the connection is completed

3) If it is not a link request, the Reactor will dispatch and call the corresponding Handler for the link to handle it

4) Handler is only responsible for event response and does not perform specific business processing

5) After reading the data through read, it is distributed to the worker thread pool for processing. After processing, it is returned to the Handler. After the Handler receives it, it returns the result to the client through send

3. Master-slave Reactor multithreading

1) Reactor main thread MainReactor object listens to link events through select and processes them through Acceptor

2) After the Acceptor processes the link event, the MainReactor assigns the link to the SubReactor

3) SubReactor adds the link to the queue for monitoring and creates a Handler for event processing

4) When a new event occurs, SubReactor will call the corresponding Handler to handle it

5) The Handler reads the data through read and distributes it to the worker thread pool for processing. After processing, it returns it to the Handler. After receiving it, the Handler returns the result to the client through send

6) The Reactor main thread can correspond to multiple Reactor sub-threads

Three modes to understand with real life cases

1) Single Reactor single thread, the front desk receptionist and waiter are the same person, serving customers throughout the process

2) Single Reactor multi-threaded, 1 receptionist, multiple waiters, the receptionist is only responsible for reception

3) Master-slave Reactor multithreading, multiple receptionists, multiple waiters

The Reactor model has the following advantages

1) Fast response, no need to be blocked by a single synchronous event, although Reactor itself is still synchronous

2) It can avoid complex multi-threading and synchronization problems to the greatest extent, and avoid the switching overhead of multi-threads/processes

3) Good scalability, you can easily increase the number of Reactor instances to make full use of CPU resources

4) Good reusability. The Reactor model itself has nothing to do with the specific event processing logic and has high reusability

Core Components

1.Bootstrap A Netty application usually starts with a Bootstrap, which is mainly used to configure the entire Netty program and connect various components in series.

Handler, in order to support various protocols and ways of processing data, the Handler component was born. Handler is mainly used to handle various events, and the events here are very broad, such as connection, data reception, exception, data conversion, etc.

2. ChannelInboundHandler is the most commonly used Handler. The function of this Handler is to handle events when data is received. In other words, our business logic is generally written in this Handler. ChannelInboundHandler is used to handle our core business logic.

3. ChannelInitializer When a link is established, we need to know how to receive or send data. Of course, we have various Handler implementations to handle it. Then ChannelInitializer is used to configure these Handlers. It will provide a ChannelPipeline and add the Handler to the ChannelPipeline.

4.ChannelPipeline A Netty application is based on the ChannelPipeline mechanism, which needs to rely on EventLoop and EventLoopGroup because all three of them are related to events or event processing.

The purpose of EventLoops is to process IO operations for Channels. One EventLoop can serve multiple Channels.

EventLoopGroup will contain multiple EventLoops.

5.Channel represents a Socket link, or other components related to IO operations. It is used together with EventLoop to participate in IO processing.

6.Future In Netty, all IO operations are asynchronous. Therefore, you cannot know immediately whether the message is processed correctly, but we can wait for it to complete or directly register a listener. The specific implementation is through Future and ChannelFutures. They can register a listener, which will be automatically triggered when the operation succeeds or fails.

Example

Through a simple example, first understand how to develop a communication program based on Netty, including the service and the client:

Server:

 @Slf4j public class Server { private EventLoopGroup boosGroup; private EventLoopGroup workGroup; public Server(int port){ try { init(port); log.info("----- 服务启动成功-----"); } catch (InterruptedException e) { log.error("启动服务出错：{}", e.getCause()); } } private void init(int port) throws InterruptedException { // 处理连接this.boosGroup = new NioEventLoopGroup(); // 处理业务this.workGroup = new NioEventLoopGroup(); ServerBootstrap bootstrap = new ServerBootstrap(); // 绑定bootstrap.group(boosGroup, workGroup) .channel(NioServerSocketChannel.class) //配置服务端.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000) .option(ChannelOption.SO_BACKLOG, 1024) .childOption(ChannelOption.TCP_NODELAY, true) .childOption(ChannelOption.SO_RCVBUF, 1024) .childOption(ChannelOption.SO_SNDBUF, 1024) .childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel socketChannel) throws Exception { socketChannel.pipeline().addLast(new ServerHandler()); } }); ChannelFuture channelFuture = bootstrap.bind(port).sync(); channelFuture.channel().closeFuture().sync(); } public void close(){ this.boosGroup.shutdownGracefully(); this.workGroup.shutdownGracefully(); } } @Slf4j class ServerHandler extends ChannelInboundHandlerAdapter { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { log.info(">>>>>>> server active"); } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { //1. 读取客户端的数据(缓存中去取并打印到控制台) ByteBuf buf = (ByteBuf) msg; byte[] request = new byte[buf.readableBytes()]; buf.readBytes(request); String requestBody = new String(request, "utf-8"); log.info(">>>>>>>>> receive message: {}", requestBody); //2. 返回响应数据ctx.writeAndFlush(Unpooled.copiedBuffer((requestBody+" too").getBytes())); } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { super.exceptionCaught(ctx, cause); } }

Client:

 @Slf4j public class Client { private EventLoopGroup workGroup; private ChannelFuture channelFuture; public Client(int port){ init(port); } private void init(int port){ this.workGroup = new NioEventLoopGroup(); Bootstrap bootstrap = new Bootstrap(); bootstrap.group(workGroup) .channel(NioSocketChannel.class) .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000) .option(ChannelOption.SO_RCVBUF, 1024) .option(ChannelOption.SO_SNDBUF, 1024) .handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel socketChannel) throws Exception { socketChannel.pipeline().addLast(new ClientHandler()); } }); this.channelFuture = bootstrap.connect("127.0.0.1", port).syncUninterruptibly(); } /** * * @param message */ public void send(String message){ this.channelFuture.channel().writeAndFlush(Unpooled.copiedBuffer(message.getBytes())); } /** * */ public void close(){ try { channelFuture.channel().closeFuture().sync(); } catch (InterruptedException e) { throw new RuntimeException(e); } workGroup.shutdownGracefully(); } } @Slf4j class ClientHandler extends ChannelInboundHandlerAdapter { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { log.info(">>>>>>> client active"); } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { try { ByteBuf buf = (ByteBuf) msg; byte[] req = new byte[buf.readableBytes()]; buf.readBytes(req); String body = new String(req, "utf-8"); log.info(">>>>>>>>> receive message: {}", body); } finally { ReferenceCountUtil.release(msg); } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { super.exceptionCaught(ctx, cause); } }

test:

 public class StarterTests { static int port = 9011; @Test public void startServer(){ Server server = new Server(9011); } @Test public void startClient(){ Client client = new Client(port); client.send("Hello Netty!"); while (true){} } }

Ecology

• Dubbo
• Spring Reactive

Similar technologies

Mina, Netty, Grizzly

other

Proactor non-blocking asynchronous network model

refer to

https://mp.weixin.qq.com/s?__biz=MzUxNDA1NDI3OA==&mid=2247492766&idx=2&sn=b5df49147561e467fa5677b5b b09dacb&chksm=f9496577ce3eec61383994499d96a7f2b091b5eb8ee1ac47ad021f78072ae710f41d38257406&scene=27

https://blog.csdn.net/a745233700/article/details/122660246