Netty is a very efficient network communication framework. Why is it efficient? The reason is a good threading model and memory management. Netty's thread model is designed and developed based on Reactor mode. Reactor mode is based on event-driven, especially suitable for handling massive I / O events.
The above picture is a Reactor thread model. Based on select (), epoll (), the Reactor thread separates I / O call requests and I / O operations. In theory, a Reactor thread can handle N network I / O operations, but when When the amount of concurrency is large, a Reactor thread will have problems such as slow response and connection timeout.
Then a Reactor thread model cannot cope with large concurrent network requests, we can further choose the Reactor thread group.
Rector multithreading has a dedicated NIO thread for monitoring the server and accepting TCP connection requests from clients. The reading and writing of network IO is handled by a NIO thread pool. This already has a high processing capacity. However, in very special cases, the NIO thread is responsible for monitoring and processing all client connections and performance issues may occur. In order to solve the performance problem, a third type of Reactor threading model-the master-slave Reactor multithreading model was produced.
The feature of the master-slave Reactor thread model is that the server receives no client connection from a single NIO thread, but an independent NIO thread pool. After receiving the client request, Acceptor registers the newly created SocketChannel to an IO thread in the IO thread pool, which is responsible for the reading, writing, encoding and decoding of SocketChannnel.
The thread model is shown below:

Specifically, NioEventLoop is the Reactor thread of Netty, which is responsible for processing client request access, and is also responsible for registering the monitoring connection operation bit, which is used to judge the result of asynchronous connection and monitoring the network read operation bit , Responsible for writing messages to the SocketChannel and sending to the other party, to perform these tasks of ordinary task threads.