Shulou(Shulou.com)05/31 Report--

This article mainly explains "how to realize BIO, NIO and AIO of Java". Interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "how to achieve Java's BIO, NIO, and AIO"!

From the level of programming language

BIO, NIO, AIO understand from the perspective of Java:

BIO, synchronous blocking IO, simple understanding: one thread at a time

NIO, synchronous non-blocking IO, simple understanding: one request one thread

AIO, asynchronous non-blocking IO, simple understanding: one valid request, one thread

BIO

Before JDK1.4, writing network requests in Java was all about creating a ServerSocket, and then when the client set up the Socket, it asked if there was a thread to process, and if not, it either waited or was rejected. That is, a connection that requires the Server to correspond to a processing thread.

Public class PlainEchoServer {public void serve (int port) throws IOException {final ServerSocket socket = new ServerSocket (port); / / Bind server to port try {while (true) {/ / Block until new client connection is accepted final Socket clientSocket = socket.accept (); System.out.println ("Accepted connection from" + clientSocket) / / Create new thread to handle client connection new Thread (new Runnable () {@ Override public void run () {try {BufferedReader reader = new BufferedReader (new InputStreamReader (clientSocket.getInputStream (); PrintWriter writer = new PrintWriter (clientSocket.getOutputStream (), true) / / Read data from client and write it back while (true) {writer.println (reader.readLine ()); writer.flush ();}} catch (IOException e) {e.printStackTrace (); try {clientSocket.close () } catch (IOException ex) {/ / ignore on close}) .start (); / / Start thread}} catch (IOException e) {e.printStackTrace ();} NIO

In the origin of Java, a set of API is provided in JDK1.4 and later versions to manipulate non-blocking IPUBO, and we can find related classes and interfaces in the java.nio package and its subpackages. Because this set of API is the new I API provided by JDK, it is also called New I API O, which is the origin of the package name nio. This set of API consists of three main parts: the buffer (Buffers), the channel (Channels), and the core class of the non-blocking Iripple O. When understanding NIO, you need to distinguish between New I NIO O and non-blocking IO,New I hand O is the package of Java, and NIO is the concept of non-blocking IO. Here we are talking about the latter.

NIO itself is based on event-driven thought, and its main purpose is to solve the problem of large concurrency of BIO: in network applications using synchronous Ibank O, if you want to process multiple client requests at the same time, or if the client wants to communicate with multiple servers at the same time, it must use multi-thread processing. That is, each client request is assigned to a thread to be processed separately. Although this can meet our requirements, it will bring about another problem at the same time. Because each thread is created, a certain amount of memory space (also known as working memory) is allocated to the thread, and the operating system itself has a certain limit on the total number of threads. If there are too many requests from the client, the server program may reject the request from the client because it is overburdened, and even the server may be paralyzed. NIO is based on Selector. When the socket has a stream to read or write to the socket, the operating system will notify the reference program to process it, and the application will read the stream to the buffer or write to the operating system. In other words, at this time, it is no longer a connection corresponding to a processing thread, but a valid request, corresponding to a thread, when the connection has no data, there is no worker thread to process.

Public class PlainNioEchoServer {public void serve (int port) throws IOException {System.out.println ("Listening for connections on port" + port); ServerSocketChannel serverChannel = ServerSocketChannel.open (); ServerSocket ss = serverChannel.socket (); InetSocketAddress address = new InetSocketAddress (port); / / Bind server to port ss.bind (address); serverChannel.configureBlocking (false); Selector selector = Selector.open () / / Register the channel with the selector to be interested in new Client connections that get accepted serverChannel.register (selector, SelectionKey.OP_ACCEPT); while (true) {try {/ / Block until something is selected selector.select ();} catch (IOException ex) {ex.printStackTrace (); / / handle in a proper way break;} / / Get all SelectedKey instances Set readyKeys = selector.selectedKeys () Iterator iterator = readyKeys.iterator (); while (iterator.hasNext ()) {SelectionKey key = (SelectionKey) iterator.next (); / / Remove the SelectedKey from the iterator iterator.remove (); try {if (key.isAcceptable ()) {ServerSocketChannel server = (ServerSocketChannel) key.channel (); / / Accept the client connection SocketChannel client = server.accept () System.out.println ("Accepted connection from" + client); client.configureBlocking (false); / / Register connection to selector and set ByteBuffer client.register (selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, ByteBuffer.allocate);} / / Check for SelectedKey for read if (key.isReadable ()) {SocketChannel client = (SocketChannel) key.channel () ByteBuffer output = (ByteBuffer) key.attachment (); / / Read data to ByteBuffer client.read (output);} / / Check for SelectedKey for write if (key.isWritable ()) {SocketChannel client = (SocketChannel) key.channel (); ByteBuffer output = (ByteBuffer) key.attachment (); output.flip () / / Write data from ByteBuffer to channel client.write (output); output.compact ();}} catch (IOException ex) {key.cancel (); try {key.channel (). Close ();} catch (IOException cex) {} AIO

Unlike NIO, when reading and writing, you only need to call the read or write method of API directly. Both methods are asynchronous, and for read operations, when there is a stream to read, the operating system passes the readable stream into the buffer of the read method and notifies the application; for write operations, when the operating system finishes writing the stream passed by the write method, the operating system actively notifies the application.

In other words, it can be understood that the read/write methods are asynchronous, and the callback function will be called actively after completion.

In JDK1.7, this part is called NIO.2, and the following four asynchronous channels are mainly added under the java.nio.channels package:

AsynchronousSocketChannel

AsynchronousServerSocketChannel

AsynchronousFileChannel

AsynchronousDatagramChannel

The read/write method returns an object with a callback function. When the read / write operation is completed, the callback function is called directly.

Public class PlainNio2EchoServer {public void serve (int port) throws IOException {System.out.println ("Listening for connections on port" + port); final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open (); InetSocketAddress address = new InetSocketAddress (port); / / Bind Server to port serverChannel.bind (address); final CountDownLatch latch = new CountDownLatch (1); / / Start to accept new Client connections. Once one is accepted the CompletionHandler will get called. ServerChannel.accept (null, new CompletionHandler () {@ Override public void completed (final AsynchronousSocketChannel channel, Object attachment) {/ / Again accept new Client connections serverChannel.accept (null, this); ByteBuffer buffer = ByteBuffer.allocate; / / Trigger a read operation on the Channel, the given CompletionHandler will be notified once something was read channel.read (buffer, buffer, new EchoCompletionHandler (channel)) } @ Override public void failed (Throwable throwable, Object attachment) {try {/ / Close the socket on error serverChannel.close ();} catch (IOException e) {/ / ingnore on close} finally {latch.countDown (); try {latch.await () } catch (InterruptedException e) {Thread.currentThread () .interrupt ();}} private final class EchoCompletionHandler implements CompletionHandler {private final AsynchronousSocketChannel channel; EchoCompletionHandler (AsynchronousSocketChannel channel) {this.channel = channel;} @ Override public void completed (Integer result, ByteBuffer buffer) {buffer.flip () / Trigger a write operation on the Channel, the given CompletionHandler will be notified once something was written channel.write (buffer, buffer, new CompletionHandler () {@ Override public void completed (Integer result, ByteBuffer buffer) {if (buffer.hasRemaining ()) {/ / Trigger again a write operation if something is left in the ByteBuffer channel.write (buffer, buffer, this);} else {buffer.compact () / / Trigger a read operation on the Channel, the given CompletionHandler will be notified once something was read channel.read (buffer, buffer, EchoCompletionHandler.this);}} @ Override public void failed (Throwable exc, ByteBuffer attachment) {try {channel.close () } catch (IOException e) {/ / ingnore on close});} @ Override public void failed (Throwable exc, ByteBuffer attachment) {try {channel.close ();} catch (IOException e) {/ / ingnore on close} implementation principle

Speaking of the implementation principle, we should also understand the division according to the "Unix network programming" from the IO model of the operating system. The IO model can be divided into blocking IO, non-blocking IO, IO multiplexing, signal-driven IO and asynchronous IO. According to the POSIX standard, it can only be divided into two categories: synchronous IO and asynchronous IO. How to tell the difference? First of all, an IO operation is actually divided into two steps: initiating an IO request and the actual IO operation. The difference between synchronous IO and asynchronous IO lies in whether the second step is blocked. If the actual IO reads and writes blocking the request process, it is synchronous IO, so blocking IO, non-blocking IO, IO multiplexing, and signal-driven IO are all synchronous IO. If there is no blocking, the operating system helps you finish the IO operation and then returns the result to you. So it's asynchronous IO. The difference between blocking IO and non-blocking IO lies in whether the originating IO request will be blocked in the first step, traditional blocking IO if blocking until completion, and non-blocking IO if not blocking.

Received the IO model of the operating system, but also had to mention select/poll/epoll/iocp. The understandable explanation is that after Linux 2.6, the implementation of java NIO is implemented through epoll, which can be found in the source code of jdk. AIO, on the other hand, is implemented through IOCP on windows and epoll on linux. One point is emphasized here: AIO, which is the Icano processing mode, while epoll and others are a programming model for implementing AIO; in other words, AIO is an interface standard that can be implemented or not implemented by various operating systems. It is best to use the way recommended by the operating system on different operating systems in the case of high concurrency. There is no real network-based AIO on Linux.

Underlying foundation

On windows, AIO is implemented through IOCP. If you look at the source code of JDK, you can find

WindowsAsynchronousSocketChannelImpl

Look at the implementation interface:

Implements Iocp.OverlappedChannel

Let's take a look at the implementation method: the read0/write0 method inside is the native method, which is called by the underlying implementation of jvm.

On linux, AIO is implemented through epoll. If you look at the JDK source code, you can find that the implementation source code is:

UnixAsynchronousSocketChannelImpl

Look at the implementation interface:

Implements Port.PollableChannel

This is the biggest difference from windows, the implementation of poll, after linux2.6, the default use of epoll.

At this point, I believe you have a deeper understanding of "how to achieve Java's BIO, NIO, AIO". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.