Shulou(Shulou.com)06/02 Report--

This article will explain in detail how to achieve NIO non-blocking network programming in Java. The content of the article is of high quality, so the editor shares it for you as a reference. I hope you will have a certain understanding of the relevant knowledge after reading this article.

Buffer (buffer)

A buffer is essentially a block of memory (similar to an array) that can be written to data, which can then be read again. This memory block is contained in the NIO Buffer object, which provides a set of methods that make it easier to use memory blocks.

Compared with the direct operation array, Buffer API provides easier operation and management. The data operation is divided into write and read. The main steps are as follows:

Write data to the buffer

Call buffer.flip () to convert to read mode

Buffer read data

Call buffer.clear () or buffer.compact () to clear the buffer

There are three important attributes in Buffer:

Capacity (capacity): as a memory block, Buffer has a fixed size, also known as capacity

Position (position): represents the location where the data is written when the mode is written, and where the data is read when the mode is read

Limit (limit): write mode is equal to the capacity of Buffer, and read mode is equal to the amount of data written.

Buffer usage code example:

Public class BufferDemo {

Public static void main (String [] args) {

/ / build a byte byte buffer with a capacity of 4

ByteBuffer byteBuffer = ByteBuffer.allocate (4)

/ / default write mode to view three important metrics

System.out.println (

String.format (

"initialization: capacity capacity:% s, position location:% s, limit limit:% s"

ByteBuffer.capacity (), byteBuffer.position (), byteBuffer.limit ())

/ / write data

ByteBuffer.put ((byte) 1)

ByteBuffer.put ((byte) 2)

ByteBuffer.put ((byte) 3)

/ / look at three important indicators again

System.out.println (

String.format (

"after 3 bytes are written: capacity capacity:% s, position location:% s, limit limit:% s"

ByteBuffer.capacity (), byteBuffer.position (), byteBuffer.limit ())

/ / converted to read mode (data can also be read without calling the flip method, but the position record is read in the wrong position)

System.out.println ("start reading")

ByteBuffer.flip ()

Byte a = byteBuffer.get ()

System.out.println (a)

Byte b = byteBuffer.get ()

System.out.println (b)

System.out.println (

String.format (

"after reading 2 bytes of data, capacity capacity:% s, position location:% s, limit limit:% s"

ByteBuffer.capacity (), byteBuffer.position (), byteBuffer.limit ())

/ / continue to write 3 bytes, and in read mode, limit=3,position=2. Continue to write only one piece of data can be overwritten

The / / clear () method clears the entire buffer. The compact () method clears only the read data. Switch to write mode

ByteBuffer.compact ()

/ / cleared 2 bytes that have been read, 1 byte left, and 3 bytes of data can be written.

/ / A java.nio.BufferOverflowException exception will be reported if you overwrite.

ByteBuffer.put ((byte) 3)

ByteBuffer.put ((byte) 4)

ByteBuffer.put ((byte) 5)

System.out.println (

String.format (

"final situation, capacity capacity:% s, position location:% s, limit limit:% s"

ByteBuffer.capacity (), byteBuffer.position (), byteBuffer.limit ())

}

} ByteBuffer out-of-heap memory

ByteBuffer provides both direct memory (direct, off-heap) and indirect memory (heap, heap) implementations for performance-critical code. The out-of-heap memory implementation allocates memory objects outside the heap of the Java virtual machine, which is directly managed by the operating system rather than the virtual machine. The result is to reduce the impact of garbage collection on applications to some extent and provide running speed.

How to obtain out-of-heap memory:

ByteBuffer byteBuffer = ByteBuffer.allocateDirect (noBytes)

Benefits of out-of-heap memory:

When doing network IO or file IO, there is one less copy than heap buffer.

(file/socket-OS memory-jvm heap) in the process of writing file and socket, GC moves the object, and in the implementation of JVM, the data is copied out of the heap and then written.

Outside the scope of GC, the pressure on GC is reduced, but automatic management is realized. There is a Cleaner object (PhantomReference) in DirectByteBuffer. Before the Cleaner is executed by GC, the clean method is executed, triggering the Deallocator defined in DirectByteBuffer.

Recommendations for the use of off-heap memory:

It is only used when the performance is really considerable, and is allocated to large, long-lived objects (network transfer, file reading and writing, etc.)

Limit the size by the virtual machine parameter MaxDirectMemorySize to prevent the entire machine from running out of memory

Channel (Channel)

Channel is used for the connection between the source node and the target node, Channel is similar to the traditional IO Stream,Channel itself can not directly access data, Channel can only interact with Buffer.

Channel's API covers the TCP/UDP network and file IO, and the commonly used classes are FileChannel,DatagramChannel,SocketChannel,ServerSocketChannel

Standard IO Stream is usually unidirectional (InputStream/OutputStream), while Channel is a bi-directional channel that can read and write within one channel, non-blocking read and write channels, and the channel always reads and writes buffers (that is, Channel must be used with Buffer).

SocketChannel

SocketChannel is used to establish a TCP network connection, similar to java.net.Socket. There are two ways to create a SocketChannel, one is a connection initiated by the client to the server, and the other is a new connection obtained by the server. There are two important methods in SocketChannel, one is the write () write method, the write () write method may return before the content has been written, and you need to call the write () method in the loop. Another is the read () read method, which may directly return that no data is read at all, and you can tell how many bytes have been read based on the int value returned.

Core code sample snippet:

/ / the client initiates a connection to SocketChannel

SocketChannel = SocketChannel.open ()

/ / set to non-blocking mode socketChannel.configureBlocking (false)

SocketChannel.connect (new InetSocketAddress ("127.0.0.1", 8080))

/ / request data occurs-write data to the channel

SocketChannel.write (byteBuffer)

/ / read server returned-read buffer data

Int readBytes = socketChannel.read (requestBuffer)

SocketChannel.close (); / / close the connection ServerSocketChannel

ServerSocketChannel can listen to the newly created TCP connection channel, similar to ServerSocket. The core method of ServerSocketChannel, the accept () method, returns null immediately if there is no pending connection if the channel is in non-blocking mode. In practice, you must check whether the returned SocketChannel is null.

Core code sample snippet:

/ / create a network server

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open ()

/ / set to non-blocking mode

ServerSocketChannel.configureBlocking (false)

/ / bind port

ServerSocketChannel.socket () .bind (new InetSocketAddress (8080))

While (true) {

/ / get a new tcp connection channel

SocketChannel socketChannel = serverSocketChannel.accept ()

If (socketChannel! = null) {

/ / tcp request read / response

}

} Selector selector

Selector is also the core component of Java NIO, which can examine one or more NIO channels and determine which channels are ready to read or write. Implementing a single thread can manage multiple channels, thereby managing multiple network connections.

A thread can listen for different events of multiple Channel using Selector. There are mainly four kinds of events, which correspond to four constants in SelectionKey. They are:

Connection event SelectionKey.OP_CONNECT

Ready event SelectionKey.OP_ACCEPT

Read event SelectionKey.OP_READ

Write event SelectionKey.OP_WRITE

The core of Selector implementing a thread to deal with multiple channels lies in the event-driven mechanism. Under the non-blocking network channel, developers register the event types that are interested in the channel through Selector, and the thread triggers the corresponding code execution by listening for events. (the underlying layer is actually the multiplexing mechanism of the operating system)

Core code sample snippet:

/ / build a Selector selector and register the channel

Selector selector = Selector.open ()

/ / Register serverSocketChannel to selector

SelectionKey selectionKey = serverSocketChannel.register (selector, 0, serverSocketChannel)

/ / interested in the accept event on serverSocketChannel (serverSocketChannel can only support accept operation)

SelectionKey.interestOps (SelectionKey.OP_ACCEPT)

While (true) {

/ / use the following way to poll events. The select method has a blocking effect and will not be returned until there is an event notification

Selector.select ()

/ / get the event

Set keys = selector.selectedKeys ()

/ / traverse the query results

Iterator iterator = keys.iterator ()

While (iterator.hasNext ()) {

/ / encapsulated query results

SelectionKey key = iterator.next ()

/ / judge different event types and execute the corresponding logic processing

If (key.isAcceptable ()) {

/ / handle the logic of the connection

}

If (key.isReadable ()) {

/ / Logic for processing read data

}

Iterator.remove ()

}

} NIO network programming complete code

Server code example:

/ / non-blocking server implemented with Selector (abandon polling on channel, with the help of message notification mechanism)

Public class NIOServer {

Public static void main (String [] args) throws IOException {

/ / create a network server ServerSocketChannel

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open ()

/ / set to non-blocking mode

ServerSocketChannel.configureBlocking (false)

/ / build a Selector selector and register the channel

Selector selector = Selector.open ()

/ / Register serverSocketChannel to selector

SelectionKey selectionKey = serverSocketChannel.register (selector, 0, serverSocketChannel)

/ / interested in the accept event on serverSocketChannel (serverSocketChannel can only support accept operation)

SelectionKey.interestOps (SelectionKey.OP_ACCEPT)

/ / bind port

ServerSocketChannel.socket () .bind (new InetSocketAddress (8080))

System.out.println ("started successfully")

While (true) {

/ / instead of polling the channel, use the following polling method for events. The select method has blocking effect, and selector.select () will not be returned until an event notification.

/ / get the event

Set keys = selector.selectedKeys ()

/ / traverse the query results

Iterator iterator = keys.iterator ()

While (iterator.hasNext ()) {

/ / encapsulated query results

SelectionKey key = iterator.next ()

Iterator.remove ()

/ / follow the Read and Accept events

If (key.isAcceptable ()) {

ServerSocketChannel server = (ServerSocketChannel) key.attachment ()

/ / register the obtained client connection channel with selector

SocketChannel clientSocketChannel = server.accept ()

ClientSocketChannel.configureBlocking (false)

ClientSocketChannel.register (selector, SelectionKey.OP_READ, clientSocketChannel)

System.out.println ("New connection received:" + clientSocketChannel.getRemoteAddress ())

}

If (key.isReadable ()) {

SocketChannel socketChannel = (SocketChannel) key.attachment ()

Try {

ByteBuffer byteBuffer = ByteBuffer.allocate (1024)

While (socketChannel.isOpen () & & socketChannel.read (byteBuffer)! =-1) {

/ / in the case of a persistent connection, you need to manually determine whether the reading of the data has ended (here to make a simple judgment: if it exceeds 0 bytes, the request is considered to be over)

If (byteBuffer.position () > 0) break

}

If (byteBuffer.position () = = 0) continue

ByteBuffer.flip ()

Byte [] content = new byte [byteBuffer.limit ()]

ByteBuffer.get (content)

System.out.println (new String (content))

System.out.println ("data received from:" + socketChannel.getRemoteAddress ())

/ / response result 200

String response = "HTTP/1.1 200 OK\ r\ n" + "Content-Length: 11\ r\ n\ r\ n" + "Hello World"

ByteBuffer buffer = ByteBuffer.wrap (response.getBytes ())

While (buffer.hasRemaining ()) {

SocketChannel.write (buffer)

}

} catch (Exception e) {

E.printStackTrace ()

Key.cancel (); / / Unsubscribe to events

}

}

Selector.selectNow ()

}

}

}

}

Client code example:

Public class NIOClient {

Public static void main (String [] args) throws IOException {

/ / the client initiates a connection

SocketChannel socketChannel = SocketChannel.open ()

/ / set to non-blocking mode

SocketChannel.configureBlocking (false)

SocketChannel.connect (new InetSocketAddress ("127.0.0.1", 8080))

While (! socketChannel.finishConnect ()) {

/ / if you are not connected, you will be waiting.

Thread.yield ()

}

Scanner scanner = new Scanner (System.in)

System.out.println ("please enter:")

/ / send content

String msg = scanner.nextLine ()

ByteBuffer byteBuffer = ByteBuffer.wrap (msg.getBytes ())

While (byteBuffer.hasRemaining ()) {

SocketChannel.write (byteBuffer)

}

/ / read response

System.out.println ("received server response:")

ByteBuffer buffer = ByteBuffer.allocate (1024)

While (socketChannel.isOpen () & & socketChannel.read (buffer)! =-1) {

/ / in the case of a persistent connection, you need to manually determine whether the reading of the data has ended (here to make a simple judgment: if it exceeds 0 bytes, the request is considered to be over)

If (buffer.position () > 0) break

}

Buffer.flip ()

Byte [] content = new byte [buffer.limit ()]

Buffer.get (content)

System.out.println (new String (content))

Scanner.close ()

SocketChannel.close ()

}

} comparison between NIO and BIO

On how to achieve NIO non-blocking network programming in Java is shared here, I hope the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

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.