The difference between JAVA BIO NiO and Aio __java

The IO approach is usually divided into several, synchronized blocked bio, synchronous non-blocking NiO, asynchronous Non-blocking AIO

A. BIO

Before the JDK1.4 came out, when we set up a network connection with the Bio mode, we need to start a serversocket on the server, and then start the socket on the client to communicate to the server, by default, the server needs to set up a heap of threads to wait for the request, and the client sends the request, first consults the server Whether the thread is appropriate, if not, it will wait or be rejected, and if so, the client will wait until the request is finished before continuing.

Two. NIO

NiO itself is based on event-driven thinking, primarily to solve the big concurrency problem of bio: In network applications that use synchronous I/O, you must use multithreading if you want to handle multiple client requests simultaneously, or if the client wants to communicate with multiple servers at the same time. In other words, each client request is assigned to a thread to handle separately. While this can meet our requirements, it also poses another problem. Because each thread is created, it allocates a certain amount of memory (also known as working memory) to the thread, and the operating system itself limits the total number of threads. If there are too many requests from the client, the server-side program may be overwhelmed to deny the client's request, and even the servers may become paralyzed.

NIO is based on reactor, and when the socket has a stream readable or writable socket, the operating system processes the corresponding notification reference program, and then reads the stream to the buffer or writes to the operating system. In other words, this time, is not a connection will be a processing thread, but a valid request, corresponding to a thread, when the connection has no data, there is no worker thread to deal with

One of the more important differences between bio and NiO is that when we use the bio, we tend to introduce multiple threads, each connecting a single thread, while NIO uses a single thread or uses only a small number of threads, and each connection has a common one.

The most important place for NIO is that when a connection is created, it does not need to correspond to a thread, this connection will be registered on the multiplexer, so all the connections need only one thread can be done, when the multiplexer in this thread polling, found the connection on the request to open a thread to handle, That is, a request for a threading pattern.

In the process of NIO, when a request comes in, open the thread to process, may wait for the backend application resources (JDBC connection, etc.), in fact, this thread is blocked, when the concurrent up, there will be the same problem with the bio.

The http/1.1 appears with an HTTP long connection so that, in addition to timing out and specifying the HTTP header for a particular shutdown, the link is always open, so that it can evolve further in NIO processing, and a resource pool or queue can be implemented in the backend resources, and when requested, The open thread sends the request and request data to the back-end resource pool or the queue to return. And in the overall place to maintain the site (which the connection of which request, etc.), so that the previous thread can still accept other requests, the application of the latter end of the processing only need to execute the queue within the can, This allows the request processing and the backend application to be asynchronous. When the backend is processed, the scene is generated to the global place, and the response is realized, and the asynchronous processing is achieved.

Three. AIO

Unlike NIO, the read or write method of the API must be invoked directly when reading and writing. Both of these methods are asynchronous, and for read operations, when there is a stream to read, the operating system transmits the readable buffer to the Read method and notifies the application; for write operations, the operating system proactively notifies the application when the operating system writes the stream passed by the write method to completion. It can be understood that the Read/write method is asynchronous and will invoke the callback function when it is finished. In JDK1.7, this part of the content is called nio.2, which adds the following four asynchronous channels, mainly under the Java.nio.channels package: Asynchronoussocketchannel Asynchronousserversocketchannel Asynchronousfilechannel Asynchronousdatagramchannel

The Read/write method, which returns an object with a callback function, calls the callback function directly when the read/write operation is completed. Bio is a connection to a thread. NIO is a request for a thread. AIO is a valid request for a thread

Let's start with an example to understand the concept of bank withdrawals as an example: Sync: Personally take the bank card to the bank to withdraw money (when using synchronous io, Java handles IO read and write itself); asynchronous: Entrust a little brother to take a bank card to the bank for money and then to you (when using asynchronous IO, Java delegates io Read and write to OS processing, The data buffer address and size need to be passed to the OS (bank card and password). OS needs to support asynchronous IO operations APIs; blocking: ATM queuing for withdrawals, you can only wait (when using blocking IO, Java calls are blocked until read-write is completed); Non-blocking: counter withdraw, take a number, And then sit in the chair and do other things, the equal sign broadcast will inform you to handle, not to the number you cannot go, you may unceasingly ask the lobby manager to have not arrived, the lobby manager if said that does not arrive you cannot go (uses non-blocking io, if cannot read and write Java call will return immediately, When the IO event distributor notifies the reader that it can read and write, continue to cycle until read and write.

Java support for bio, NIO, Aio: Java Bio: Synchronization and blocking, server implementation mode for a connection to a thread, that is, the client has a connection request, the server will need to start a thread to process, if this connection does not do anything will cause unnecessary threading overhead, Of course, can be improved through the thread pool mechanism. Java NIO: Synchronous non-blocking, server implementation mode for a request of a thread, that is, the client sent a connection request will be registered to the multiplexer, multiplexer polling to connect with I/O requests before starting a thread to process. Java AIO (nio.2): Asynchronous non-blocking, server implementation mode for a valid request of a thread, the client's I/O requests are completed by the OS first and then notify the server application to start the thread processing

Bio, NIO, AIO application Scenario Analysis: Bio method suitable for a small number of connections and fixed architecture, this way for server resource requirements are relatively high, concurrent limited to applications, JDK1.4 before the only choice, but the program intuitive simple and easy to understand. NiO method suitable for the number of connections and relatively short (light operation) of the architecture, such as chat server, concurrency limited to applications, programming is more complex, JDK1.4 began to support. AIO mode for the number of connections and relatively long (heavy operation) of the architecture, such as photo albums Server, fully invoke the OS to participate in concurrent operations, programming is more complex, JDK7 began to support

In addition, I/O belongs to the underlying operation, requires operating system support, concurrency also requires the support of the operating system, so the performance of different operating system differences will be more obvious.
In High-performance I/O design, there are two well-known patterns reactor and Proactor modes, where the reactor mode is used to synchronize I/O, while Proactor is applied to asynchronous I/O operations.

Before you compare these two patterns, we first understand a few concepts, what is blocking and non-blocking, what is synchronous and asynchronous, synchronous and asynchronous are for application and kernel interaction, synchronization refers to the user process triggering IO operations and waiting or polling to see if the IO operation is ready, Asynchronous means that the user process triggers the IO operation and then starts to do its own thing, and when the IO operation has been completed, it will be notified of IO completion. And blocking and non-blocking are aimed at the process when accessing the data, depending on how the IO operation is ready, it is a way to read or write a function that reads or writes to the function, and the read or write functions will wait instead of blocking, and the read or write function immediately returns a status value.

Generally speaking I/O model can be divided into: synchronous blocking, synchronous non-blocking, asynchronous blocking, asynchronous non-blocking IO

Synchronous blocking IO : In this way, the user process must wait for the IO operation to complete after an IO operation is initiated, and the user process will not run until the IO operation is actually completed. The Java traditional IO model belongs in this way.
Synchronous non-blocking io : In this way, the user process initiates an IO operation to return to doing other things, but the user process needs to ask the IO operation to be ready from time to time, which requires the user process to constantly ask, In order to introduce unnecessary waste of CPU resources. The current Java NiO belongs to synchronous non-blocking io.
Asynchronous blocking IO : This means that after the application initiates an IO operation, does not wait for the kernel IO operation to complete, and so on the kernel completes IO operation will notify the application, this is actually synchronous and asynchronous most key difference, Synchronization must wait or actively ask if IO is complete, so why is it blocked? Because this is done by a select system call, and the Select function itself is implemented in a blocking way, the advantage of the Select function is that it can listen for multiple file handles at the same time, increasing the concurrency of the system.
Asynchronous Non-blocking io : In this mode, the user process only needs to initiate an IO operation and then return immediately, and when the IO operation is truly completed, the application will be notified of the IO operation, at which point the user process needs only to process the data. No actual IO reads or writes are required, because the true IO read or write operation has been completed by the kernel. There is currently no support for this IO model in Java.