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

Today, the editor will share with you what are the relevant knowledge points of Java NIO, the content is detailed and the logic is clear. I believe most people still know too much about this knowledge, so share this article for your reference. I hope you can get something after reading this article. Let's take a look at it.

The difference between No-Block and Block IO:

A typical network communication step is: open (new socket Chanel)-> connect (attempt to establish a connection)-> accept (connection accepted)-> read (read request) send (output result)-> close (connection closed).

For a No-Block network IO, each of the above steps will be returned immediately, of course, the returned result may be null, may not be null, which depends on the decision above (context). In general, we need results that are not for null, which requires us to take the right steps at the right time, so that we can get the results we want. What is the right time? We'll talk about this later.

For a block network IO, if each of the above steps is not executed at the right time, the current thread will be held by block until the appropriate time to return you the determined result.

Of course, for No-Block or Block IO, it is possible to throw an IOException exception at each step above.

Several key concepts that NIO programming encounters:

Buffer: a contiguous block of memory that is a transit point for reading or writing NIO data. Buffer, this blog article will not be mentioned for the time being.

Chanel: the source or destination of the data, which is used to provide data to buffer or read buffer data.

Note that there are two types of chanel, one is called SocketChanel, the other is called ServerSocketChanel, we can see by the name, one is ordinary socket chanel, which is used on both the client side and the server side, and the other is specifically used on the server side. Of course, this boundary is not absolute, and there are cases of mutual client and server.

Selector: the listener of the chanel event that detects events on one or more channels (channel) and distributes them. Using a single select thread, you can listen for events on multiple channels and trigger corresponding responses based on event drivers.

SelectionKey: an event that occurs on a chanel, containing the status information and time of the event and the corresponding chanel.

Status of Chanel:

Connectable: when a Chanel completes the socket connection operation has completed or has failed to abandon.

Acceptable: when a Chanel is ready to accept a new socket connection.

Readable: when a Chanel can be read.

Writable: when a Chanel can be written.

Combined with the above network communication steps, we can have the following conclusions:

When a Server Chanel is Connectable, the client side tries connect successfully.

When a Server Chanel is Acceptable, the client connection request is actually accepted, a new chanel is generated, and the localAdrress and remoteAddress are recorded. Prepare for further reading and writing.

When a Chanel is Readable, we will be successful in reading data from this Chanel.

When a Chanel is a Writable, we can only succeed in writing data to this Chanel.

Remember, for a No-Block Chanel, the above four operations will immediately return or throw IOException, but it is difficult to say whether it is successful or not. As mentioned earlier, when we do operations in a Chanel, we should pay close attention to the current status of the Chanel. Only when we know the current state of the Chanel can we do the most appropriate action on this Chanel.

Smart you may immediately think that if you can grab the state transition information of the Chanel you are operating, these problems will be easily solved. By the way, this is how NIO is designed. A Chanel can register a Selector (just like an event listener), and you have to tell you what state you want to listen on. Use a piece of code to illustrate:

Selector = SelectorProvider.provider (). OpenSelector (); serverChannel1 = ServerSocketChannel.open (); serverChannel1.configureBlocking (false); InetSocketAddress isa = new InetSocketAddress ("localhost", 9999); serverChannel1.socket (). Bind (isa); serverChannel1.register (selector, SelectionKey.OP_ACCEPT)

This code means that we open a ServerChanel, listen on port 9999 of the machine, and create a new Selector, and then the ServerChanel registers the Selector and specifies that the state type it is interested in is OP_ACCEPT. What's the effect of this?

Pay attention to the red sentence, which means that when selector asks serverChannel1 to have the status of acceptable, tell selector the message.

The effect is:

When the ServerChanel status is Acceptable, Selector receives a message, which is, of course, a SelectionKey object. By calling the selectedKeys () method of Selector, we can get all the messages sent by Chanel.

Because the SelectionKey contains the state, time, and corresponding Chanel of the event, naturally, we iterate through the Set, and according to the state of the SelectionKey, we can do the correct operation in the corresponding Chanel. For example, we read when we can read and write when we can.

* explain the general steps of Server and Client programming:

For Client, it generally looks like this:

InetSocketAddress isa = new InetSocketAddress (host, port); SocketChannel sc = null; sc = SocketChannel.open (); sc.connect (isa); sc.write (data); … Sc.read (buff)

Construct an InetSocketAddress object-- > open-- > connect-- > write-- > read

Note that the No-Block approach is not used here, because it is pointless for client to take the next step if it does not get the correct response from the server side.

Server side:

Selector = SelectorProvider.provider (). OpenSelector (); serverChannel = ServerSocketChannel.open (); serverChannel. Blocking reblocking (false); InetSocketAddress isa = new InetSocketAddress ("localhost", 9999); serverChannel. Socket (). Bind (isa); serverChannel. Register (selector, SelectionKey. OP_ACCEPT)

Construct a Selector-- > Open a serverSocketChanel-- > set serverSocketChanel to no-block-- > bind serverSocketChanel to a host and port-- > register Selector and inform you of the state type transition you are interested in.

Traverse the operation on SelectionKey Set:

While (true) {selector.select (); Iterator selectedKeys = this.selector.selectedKeys (). Iterator (); while (selectedKeys.hasNext ()) {SelectionKey key = (SelectionKey) selectedKeys.next (); selectedKeys.remove (); if (! key.isValid ()) {continue;} if (key.isAcceptable ()) {accept (key);} else if (key.isReadable ()) {read (key) } else if (key.isWritable ()) {write (key);}

In this loop, we will take different actions according to the state of the SelectionKey. When the connection is accepted, a new chanel is generated, and the localAdrress and remoteAddress. Prepare for further reading and writing.

The accept function is as follows:

Public void accept (SelectionKey key) throws IOException {ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel (); SocketChanel socketChannel1 = serverSocketChannel.accept (); socketChannel1.configureBlocking (false); socketChannel1.register (selector, SelectionKey.OP_READ);}

Here the new Chanel is built, and * * will also register with the selector, requiring that when the Chanel is Readable, a SelectionKey is put into the Selector. So the above loop will use read (key) to process the SelectionKey.

These are all the contents of the article "what are the knowledge points of Java NIO". Thank you for reading! I believe you will gain a lot after reading this article. The editor will update different knowledge for you every day. If you want to learn more knowledge, please pay attention to the industry information channel.

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.