From I/O multiplexing to Netty, we also need to cross the Java NIO package

[[389262]]

In the previous article, we took a deep look at the three implementation forms of I/O multiplexing, select/poll/epoll.

So what kind of I/O multiplexing does Netty use? This question starts with the Java NIO package.

Netty is actually a packaged framework, and its network I/O essentially uses the Java NIO package (New IO, not the NIO of the network I/O model, Nonblocking IO). Therefore, from the network I/O model to Netty, we also need to understand the Java NIO package.

This article is expected to take 5 minutes to read and will focus on answering the following questions:

• How to implement a server using Java NIO package
• How does the Java NIO package implement the I/O multiplexing model?
• With the Java NIO package, why do we need to encapsulate a Netty?

1. Let's take a look at an example of a Java NIO server

In the previous article, we have learned how to implement I/O multiplexing.

That is, the IO of multiple processes can be registered to a multiplexer (selector), and then one process calls select, which will monitor all registered IO.

The NIO package has implemented the corresponding implementation, as shown in the following figure.

There is a unified selector responsible for monitoring all channels. As long as there is an IO action in these channels, it can be detected through the Selector.select() method, and the selectedKeys can be used to get these channels with IO, and then the corresponding IO operations can be called on them.

Let's do a simple demo to demonstrate how to use the three core components of NIO (Buffer, Channel, Selector) to write a server program.

 public class NioDemo {
 public   static void main(String[] args) {
 try {
 //1. Create channel
            ServerSocketChannel socketChannel1 = ServerSocketChannel. open ();
 //Set to non-blocking mode, the default is blocking
            socketChannel1.configureBlocking( false );
            socketChannel1.socket().bind(new InetSocketAddress( "127.0.0.1" , 8811)); 
 
            ServerSocketChannel socketChannel2 = ServerSocketChannel. open ();
            socketChannel2.configureBlocking( false );
            socketChannel2.socket().bind(new InetSocketAddress( "127.0.0.1" , 8822)); 
 
 //2. Create a selector and register channel1 and channel2.
            Selector selector = Selector. open ();
            socketChannel1.register(selector, SelectionKey.OP_ACCEPT);
            socketChannel2.register(selector, SelectionKey.OP_ACCEPT); 
 
 while ( true ) {
 //3. Block until at least one channel is ready
 int readChannelCount = selector.select ( );
 Set <SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
 //4. The channels that are ready for rotation training
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next ( );
                    iterator.remove();
 //5. Determine the event type that is ready and handle it accordingly
                    if ( key .isAcceptable()) {
 // Create a new connection, register the connection with the selector, and declare that this channel is only interested in read operations.
                        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key .channel();
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        socketChannel.configureBlocking( false );
                        socketChannel.register(selector, SelectionKey.OP_READ);
 }
                    if ( key .isReadable()) {
                        SocketChannel socketChannel = (SocketChannel) key .channel();
                        ByteBuffer readBuff = ByteBuffer.allocate(1024);
                        socketChannel.read( readBuff );
                        readBuff.flip();
                        System. out .println( "received : " + new String(readBuff.array()));
                        socketChannel.close () ;
 }
 }
 }
        } catch (IOException e) {
            e.printStackTrace();
 }
 }
 }

Through this code example, we can clearly understand how to use the Java NIO package to implement a server:

• 1) Create channel1 and channel2, listening to specific ports respectively.
• 2) Create a selector and register channel1 and channel2.
• 3) selector.select() blocks until at least one channel is ready.
• 4) Channels that are ready for rotation training
• 5) And make corresponding response actions according to the event type. After the program starts, it will be blocked in selector.select().

Calling localhost:8811 or localhost:8822 through the browser can trigger our server code.

2. How does the Java NIO package implement the I/O multiplexing model?

The Java NIO server demonstrated above has clearly shown the process of writing server programs using NIO.

So how is I/O multiplexing achieved in this process?

We have to take a closer look at the implementation of the selector.

 //2. Create a selector and register channel1 and channel2.
 Selector selector = Selector. open ();

Start from open here.

A SelectorProvider is used here to create the selector.

Enter SelectorProvider.provider() and see that the specific provider is

sun.nio.ch.DefaultSelectorProvider creates the corresponding method:

Huh? It turns out that different operating systems provide different provider objects, including PollSelectorProvider, EPollSelectorProvide, etc.

Does the name look familiar?

That's right, it's related to the different implementation methods of I/O multiplexing, poll/epoll, which we analyzed in the previous article.

We choose the default

Look down at sun.nio.ch.PollSelectorProvider.

OK, the implementation class PollSelectorImpl is found.

Then, by calling:

Find the final native method poll0.

Still looks familiar?

That’s right! It is consistent with the poll function we analyzed in the previous article.

 int poll (struct pollfd *fds, unsigned int nfds, int timeout);

After going around for so long, in the end, we found the poll implementation of I/O multiplexing that we talked about.

At this point, we have finally connected Java NIO and the I/O multiplexing model in series.

The Java NIO package uses selectors to implement the I/O multiplexing model.

At the same time, there will be different poll/epoll options in different operating systems.

3. Why do we need Netty?

Now that we already have the NIO package, we can manually write the service framework ourselves. Why do we need to encapsulate a Netty framework? What are the benefits?

Of course there are many benefits! Let’s start with the demo we implemented at the beginning.

3.1 Design Pattern Optimization

Our demo does work, but there are still some obvious problems. Step 4 (polling the ready channels) and step 5 (handling the events accordingly) are in the same thread. When event processing is time-consuming or even blocked, the entire process will be blocked.

What we actually use is the "single Reactor single thread" design pattern.

This model is responsible for listening to ports and receiving requests in Reactor. If it is a connection event, it is handled by acceptor. If it is a read-write event and business processing, it is handled by handler. However, there is always only one thread to execute everything.

In order to improve performance, we can of course hand over event processing to the thread pool, which can evolve into the "single Reactor multi-threaded" design pattern.

The main difference between this model and the first model is that the business processing is separated from the previous single thread and replaced with thread pool processing. The Reactor thread only handles connection events and read and write events, and all business processing is handed over to the thread pool, making full use of the resources of multi-core machines and improving performance.

But it's still not enough!

We can find that a Reactor thread is responsible for all network events, such as listening and responding, and there are performance issues with a single thread in high-concurrency scenarios.

In order to make full use of multi-core capabilities, two Reactors can be built. The master Reactor listens to the server socket alone, accepts new connections, and then registers the established SocketChannel to the specified slave Reactor. The slave Reactor then performs event reading, writing, and distribution, and throws business processing to the worker thread pool. This evolves into the "master-slave Reactor mode" design pattern.

So, wouldn’t it be great if someone could encapsulate such a design pattern for us directly?

That’s right, Netty is such a “living Lei Feng”!

Netty uses the master-slave Reactor model to encapsulate the use of the Java NIO package, greatly improving performance.

3.2 Other advantages (future core knowledge points)

In addition to encapsulating high-performance design patterns, Netty has many other advantages:

Stability . Netty is more reliable and stable, and many known issues of JDK NIO have been fixed and improved, including issues such as select idling causing 100% CPU consumption and keep-alive detection.

Performance optimization . Object pool reuse technology. Netty reuses objects to avoid the overhead caused by frequent creation and destruction. Zero copy technology. In addition to the zero copy technology at the operating system level, Netty provides zero copy technology for user mode, which directly uses DirectBuffer when reading and writing I/O, avoiding the copying of data between heap memory and off-heap memory.

Convenience . Netty provides many commonly used tools, such as line decoder, length field decoder, etc. If we use the JDK NIO package, these common tools need to be implemented by ourselves.

It is precisely because Netty has achieved high performance, high stability, and high usability, which perfectly makes up for the shortcomings of Java NIO. Therefore, when we do network programming, we prefer Netty instead of using Java NIO directly.

Looking back at the previous chapters, so far, we have started from the network I/O model and have gradually understood Netty's network I/O model.

We also have a comprehensive understanding of the relationship between I/O multiplexing, Java NIO package and Netty.

With this knowledge base, we have a preliminary understanding of what Netty is and why Netty is used.

In the following articles, we will gradually expand the core knowledge points of the Netty framework, so stay tuned.