Characteristics:
- High-performance, event-driven, asynchronous non-blocking Java open source framework
- NIO-based client, server-side programming framework
- Stability and Scalability
It is often used to establish a TCP/IP underlying connection to establish a high-performance Http server.
Due to high performance, asynchronous non-blocking and other characteristics, many high-performance projects as the underlying communication base, such as Ali's Dubbo.
Main areas of activity:
- High performance areas
- Multithreading concurrency Domain
- The field of asynchronous communication
IO communication
As for this piece, I have seen a very good article written in the past to explain:
About synchronous, asynchronous, parallel, concurrency, and more
The following is a brief introduction.
BIO
A thread is responsible for the connection.
is a thread responsible for listening, it receives the request from the client, creates a new thread for each request to process, after processing is completed through the output stream back to the client, a typical request to answer the request model .
This model lacks elastic scalability, the number of processing threads on the server and the number of concurrent accesses to the client are 1:1, and the number of threads is inflated resulting in a significant decrease in efficiency, even when the thread's stack overflows and the new thread cannot be created.
Pseudo-Asynchronous IO communication
Use the thread pool to be responsible for connections.
encapsulates a user's request into a task and then throws it into the thread pool for processing (which also uses the queue), corresponding to the M request N reply relationship .
Because the thread pool is controllable, there is generally no resource exhaustion at high concurrency, but the thread pool is blocked .
PS: All require a thread to do the listening, it will encapsulate the request, and post it to the thread pool.
NIO Communication
The key three words: Buffer, channel, multiplexer (Selector).
It will have an object with buffer buffers, containing some data to be written or read out,all of the data in the NIO library is handled in buffer , and in the flow operation of the programming layer, either read or write is in the operation buffer.
Channel channels and streams are different, it is bidirectional , and the stream can only be unidirectional, so the channel may be read, write operations, or both.
Multiplexer Selector, simply stated, it will constantly poll the channel on it, if read or write on a channel to indicate that the channel is in the ready state, and then through the Selector can get the ready state of the channel collection, Then proceed with the subsequent operation.
It has no limit on the maximum number of connections and is a huge step forward in the IO field.
AIO Communication
Connection registration Read-write events and callback functions, the read-write method is really asynchronous, will actively notify the program.
AIO uses the system's underlying model (the asynchronous socket channel corresponds to the event-driven IO in Unix, is the true asynchronous non-blocking IO), and actively notifies the process , so it does not require the multiplexer to achieve asynchronous read-write, simplifying the NIO programming model .
Compare the number of clients (client: Server):
Bio:1:1
Pseudo-Asynchronous Io:m:n
Nio:m:1
aio:m:0
Type:
BIO: Blocking synchronization
Pseudo-Asynchronous IO: Blocking synchronization
NIO: Non-blocking synchronization
AIO: Non-blocking asynchronous
Integrated use
Use difficulty: BIO <
pseudo asynchronous IO <
AIO <
NIO
Debug Difficulty: BIO <
pseudo asynchronous IO <
NIO 约=
AIO
Reliability: BIO <
pseudo asynchronous IO <
NIO 约=
AIO
Throughput: BIO <
pseudo asynchronous IO <
NIO 约=
AIO
Netty Getting Started
Native NIO's class library and API complex, need to master buffer, selector, channel; entry threshold high (also requires skilled Java multi-threading, network programming)
The workload and difficulty of the reliability capability is high, and there may be some bugs with JDK NIO.
and Netty,api simple, low entry threshold, high performance, mature and stable.
Here is a small program using Netty + WebSocket: GitHub address
WebSocket
HTML5 protocol specification, through the handshake mechanism, the client and the server to establish a TCP-like connection, convenient for client and server communication.
It is to solve the problem of real-time communication between the client and the server , sending a special request via HTTP or HTTPS, and then establishing a TCP connection for exchanging data after the handshake, and then the client and the server communicate in real-time through this connection.
Avoids the "real-time" effect by polling, saving communication overhead, because servers can proactively send data to clients, and they can push information to each other at any time.
When it is closed, the server shuts down the underlying TCP, and the client can also initiate TCP close.
About NIO
A better answer to the quote: https://www.zhihu.com/question/24322387/answer/282001188
NIO is not a unique Java concept, and NiO represents a term called IO multiplexing.
It is a system call provided by the operating system , the name of the earlier operating system call is SELECT, but the performance is low, and then gradually evolved into Linux under the Epoll and Mac Kqueue.
We are generally said to be epoll, because no one takes the Apple computer as a server to use external services. Netty is a set of frameworks based on Java NIO technology encapsulation.
Why encapsulation? Because native Java NIO is less convenient to use, and the infamous Bug,netty encapsulates it, it provides an easy-to-use usage pattern and interface that users can use more easily.
What exactly is NIO?
The full name of NIO is noneblocking io, non-blocking IO; the difference with Bio,bio is Blocking io, blocking IO.
What does this block mean?
- Accept is blocked, only the new connection comes, accept will return, the main thread to continue
- Read is blocked, only the request message comes, read can return, and the child thread can continue processing
- Write is blocked, only the client has received the message, write can return, and the child thread can continue to read the next request
so the traditional multi-threaded server is Blockingio mode, all the threads are blocked from beginning to end. These threads are just waiting, consuming the operating system's scheduling resources, doing nothing, and wasting.
So how does NIO do non-blocking? It uses the event mechanism .
It can use a thread to Accept, read and write operations, request processing logic all dry . If nothing is done, it does not die in cycles, it sleeps the thread until the next event comes up and then continues to work , a thread called the NIO thread.
while (true) { takeEvents(fds); // 获取事件,如果没有事件,线程就休眠 for (event : events) { if (event.isAcceptable()) { doAccept// 新链接来了 elseif (event.isReadable()) { doRead// 读消息 if (request.isComplete()) { doProcess(); } elseif (event.isWriteable()) { doWrite(); // 写消息 } }}
The above paragraph is the pseudo-code of this process, and there are many differences with the real code.
About Netty
Netty is based on NIO, and Netty provides a higher level of abstraction over NiO.
In Netty, the Accept connection can be handled using a separate thread pool, and read and write operations are another thread pool to handle.
The Accept connection and read and write operations can also be processed using the same line pool. The request processing logic can be processed either with a separate thread pool or with a read-write thread. Each thread in a thread pool is a NIO thread. The user can assemble according to the actual situation, construct the concurrency model which satisfies the system requirement.
Netty provides a built-in common codec, including a line codec [one request], a prefix length codec [first N bytes to define the requested byte length], a replay decoder [record the status of a half-packet message],http codec, WebSocket message codec, etc.
Netty provides some column lifecycle callback interfaces, when a complete request arrives, when a connection is closed, when a connection is established, the user receives a callback event and then handles the logic.
Netty can manage multiple ports at the same time, and the NIO client model can be used, which is necessary for RPC services.
Netty can handle UDP sockets in addition to handling TCP sockets.
In the process of message reading and writing, it is necessary to use a lot of bytebuffer,netty to optimize and abstract the bytebuffer performance and usability.
In short, Netty is a must-have for Java programmers. If you know it, and want to know why, we must study the Netty. If you think Java is dull and pointless, Netty is the key to unlocking your Java interests.
A powerful tool for building highly available distributed systems--netty