How to use non-blocking I/O in Java

This article mainly introduces the use of Java non-blocking I/O. The article involves an introduction to non-blocking I/O. It also shows you how to use non-blocking I/O to implement the client. Friends who need it can refer to it. .

Most of the knowledge and examples come from O'REILLY's "Java Network Programming, Fourth Edition, by Elliotte Rusty Harold (O'REILLY)".

Introduction to non-blocking I/O

Non-blocking I/O (NIO) is a means of handling high concurrency. In the case of high concurrency, the overhead of creating and recycling threads and switching between threads becomes not negligible. At this time, non-blocking I/O technology can be used. The core idea of ​​this technology is to select a prepared connection at a time, fill as much data as the connection can manage as quickly as possible, and then move to the next prepared connection.

Client implemented using non-blocking I/O

Under normal circumstances, the client will not need to handle a high number of concurrent connections . In fact, non-blocking I/O is mainly designed for servers, but it can be used on clients as well. Since the design of the client is easier than that of the server, the client will be used for a simple demonstration below.

First introduce channel (channel) and buffer. The SocketChannel class is used to create connections in non-blocking I/O. To obtain a SocketChannel object, you need to pass a SocketAddress object (usually its subclass InetSocketAddress) into its static factory method open(). The following is an example:

SocketAddress address = new InetSocketAddress("127.0.0.1", 19);
SocketChannel client = SocketChannel.open(address);

The open() method is blocking, so the code after this will not be executed until the connection is established. If the connection cannot be established, an IOException will be thrown.

After the connection is established, input and output need to be obtained. Unlike traditional getInputStream() and getOutputStream(), with channels, you can write directly to the channel itself. Instead of writing to a byte array, a ByteBuffer object is written. The ByteBuffer object is obtained through ByteBuffer.allocate(int capacity). Capacity is the buffer size in bytes:

ByteBuffer buffer = ByteBuffer.allocate(74);

After obtaining the ByteBuffer object, pass it to the SocketChannel object The read() method, the SocketChannel object will fill this buffer with the data read from the Socket. The read() method returns the number of bytes successfully read and stored in the buffer. By default, it will read at least one byte, or return -1 to indicate end of data, and block when no bytes are available. This behaves in much the same way as an InputStream. But if set to non-blocking mode, it will return 0 immediately when no bytes are available and will not block.

Now assume that there is already some data in the buffer, and you need to extract it later. You can use the traditional method, first writing the data to a byte array, and then writing it to an output stream. Here is a completely channel-based method: use the Channels tool class to encapsulate the output stream into a channel:

WritableByteChannel out = Channels.newChannel(System.out);

The above code encapsulates System.out into a channel middle. After this the output can be made. Before each output of the ByteBuffer object, its flip() method needs to be called so that the channel starts reading from the beginning. After reading and writing, you still need to call its clear() method to reset the status of the buffer. The following is the code for a data output:

buffer.flip();
out.write(buffer);
buffer.clear();

Example 1: CharGenerator (character generator) client implemented using non-blocking I/O

Server code:

public static void createCharGeneratorServer(){
  try(ServerSocket server = new ServerSocket(19)){
    while(true){
      try(Socket connection = server.accept()){
        OutputStream out = connection.getOutputStream();
        int firstPrintableCharacter = 33;
        int numberOfPrintableCharacter = 94;
        int numberOfCharactersPerLine = 72;
        int start = firstPrintableCharacter;
        while(true){
          for(int i = start ;
              i < start + numberOfCharactersPerLine ; i++){
            out.write
            (firstPrintableCharacter + (i - firstPrintableCharacter) % numberOfPrintableCharacter);
          }
          out.write(&#39;\r&#39;);
          out.write(&#39;\n&#39;);
          start = firstPrintableCharacter + (start + 1 - firstPrintableCharacter) % numberOfPrintableCharacter;
        }
      }catch (IOException e) {
        e.printStackTrace();
      }
    }
  } catch (IOException e) {
    e.printStackTrace();
  }
}

Client code:

try {
  SocketAddress address = new InetSocketAddress("127.0.0.1", 19);
  SocketChannel client = SocketChannel.open(address);
  ByteBuffer buffer = ByteBuffer.allocate(74);
    WritableByteChannel out = Channels.newChannel(System.out);
  while(client.read(buffer) != -1){
    buffer.flip();
    out.write(buffer);
    buffer.clear();
  }
} catch (IOException e) {
  e.printStackTrace();
}
输出（无限循环）：
]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEF
^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFG
_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGH
`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGHI
abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGHIJ
bcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGHIJK

Enable non-blocking mode

The above program is not much different from the traditional way of using input/output streams. However, you can call ServerSocket's configureBlocking(false) method to set it to non-blocking mode. In this mode, if no data is available, the read() method will return immediately, allowing the client to do other things. However, since the read() method will return 0 when the data cannot be read, the loop for reading the data needs to be modified:

while(true){
  //这里可以写每次循环都要做的事，无论有没有读到数据
  int n = client.read(buffer);
  if(n > 0){
    buffer.flip();
    out.write(buffer);
    buffer.clear();
  }else if (n == -1) {
    //除非服务器故障，否则不会发生
    break;
  }
}

Summary

The above is the detailed content of How to use non-blocking I/O in Java. For more information, please follow other related articles on the PHP Chinese website!