Non-blocking server in Java NIO

Non-blocking Server

Java NIO (New Input/Output) is a very powerful networking and file-handling application that functions as an alternative to Java's standard IO API. Due to the addition of more sophisticated features since JDK 4's introduction, it has quickly emerged as the preferred I/O system among numerous engineers.

The improved support for file handling and file system functions provided by Java NIO is one of its differentiating features. Because the NIO file class has such powerful functions, it is widely used in file processing.

If you look carefully, you will notice that the java.nio package specifies the buffer classes used in the NIO API. The best part is that it was created to enable Java programmers to achieve fast I/O without writing native code.

Blocking and non-blocking I/O

Due to its use of non-blocking I/O, a non-blocking server can handle multiple requests at the same time through the same process or thread. Think of the blocking process as a queue at the ticket office, where each customer must wait for the person in front to be served before continuing.

In contrast, a non-blocking process is like a waiter at a restaurant who tries to serve all customers simultaneously by rotating through them and taking care of their orders.

The blocking server works in a synchronous manner, completing each request before moving on to the next. This can result in long client wait times and requires multiple threads to handle each request, making it more CPU demanding. Non-blocking servers, on the other hand, take an asynchronous approach, allowing one thread to handle multiple queries at the same time, reacting to the completion of each request.

Features of Java NIO

Java NIO has some unique features that set it apart from other IO systems. The following are the main features of Java NIO:

• Asynchronous and Non-Blocking IO − This feature allows for threads to perform other tasks while data is being read into a buffer. Instead of waiting for data to be fully loaded before processing begins, threads can continue their work while the data is being read.

• Buffer-oriented approach − Java NIO stores data in a buffer so that it can be accessed and processed quickly. When data is needed, it is retrieved from the buffer and processed.

algorithm

• Step 1 − To begin with, we must import the necessary classes using the import statement.

• Step 2 − Next, we need to create a public class named "WriteExample2."

• Step 3 − Inside this class, we must define a public static void main function that accepts String-type variable arguments.

• Step 4 − Now, create a temporary file with the ".txt" extension by using the Files.createTempFile() method. To write, we can use the Files.write() method along with an iterable object holding the strings "Hello" and "world."

• Step 5 − To read every byte from the file defined by the Path object returned by the Files' createTempFile() function, we can use the Files.readAllBytes() function. After that , we need to convert them to a String using the new String() constructor.

• Step 6 − Lastly, print the String to the console using the System.out.println() method.

Example 1

This Java code creates a temporary text file and writes "Hello" and "world" to it. It then reads the file and prints its contents. The code uses the Files class from the Java NIO package to handle file operations.

package com.tutorialspoint.example.files;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;

public class WriteExample2 {
   public static void main(String... args) throws IOException {
      Path path = Files.createTempFile("test-file", ".txt");
      Iterable<String> iterable = Arrays.asList("Hello", "world");
      Files.write(path, iterable);
      byte[] bytes = Files.readAllBytes(path);
      System.out.println(new String(bytes));
   }
}

Output

Hello
world

Components of Java NIO

Java NIO is built on three fundamental components: Buffers, Channels, and Selectors. Here's a brief overview of each −

• Buffer− A buffer is a block of memory used to temporarily store data while it is being transferred from one location to another. In Java NIO, buffers are used to easily read and write data.

• Channel - In Java NIO, a channel represents a connection to an object that can perform IO operations, such as files and sockets. Channels are responsible for transferring data between buffers and the objects they represent.

• Selectors − A selector is a Java NIO component used to monitor one or more channels for events, such as readiness to perform an I/O operation. When a channel is ready, the selector can wake up and allow the appropriate thread to handle the operation.

Non-Blocking Server Composition

Non-blocking servers are composed of a non-blocking IO pipeline, which is a chain of components that process both read and write IO operations in a non-blocking fashion. Here's a breakdown of how this pipeline works −

• A selector is used by each component in the pipeline to determine whether a channel has data to read.

• When there is data, the component reads it and provides output based on it. After that, the output is written back to the channel.

• Based on components, non-blocking IO pipes can read and write data, as well as perform both operations.

• This component reads data from the channel through the selector. Java NIO manages non-blocking IO operations, while selectors and selectable channel selection keys define multiplexed IO operations.

• Non-blocking IO pipelines divide data into logically ordered or combined messages alongside non-blocking data processing. This is comparable to using Java's StreamTokenizer class to tokenize a stream of data before processing it.

• Non-blocking models employ Java NIO selectors to check and give only those SelectableChannel instances that have data to read, as opposed to blocking IO pipelines, which use an interface similar to InputStream and only allow one byte to be read at a time.

Comparison of Blocking and Non-Blocking Models for Server Read/Write Operations

In the world of server architecture, choosing to use a blocking or non-blocking model for read and write operations can greatly affect the efficiency and scalability of the server.

The non-blocking model is the opposite of the blocking model, which allows a process to handle multiple concurrent requests by interleaving non-blocking I/O calls.

To illustrate the difference between these models, let's consider a hypothetical server that receives two requests. In a blocking model, the process must wait for request A to be fully processed before moving on to request B. In contrast, a non- blocking model can handle both requests simultaneously by interleaving the processing of requests A and B.

Java NIO enables a single thread to control multiple channels and supports non-blocking I/O.

The channels that link a buffer and an object at the other end make asynchronous data transfer possible. Two classes, SocketChannel and ServerSocketChannel, implement the Java NIO channel and make it possible to receive and write data over TCP connections.

Server architects can create systems that are effective, scalable, and can manage numerous simultaneous requests by selecting the proper I/O model.

in conclusion

Java NIO provides a powerful networking and file-handling application with improved support for file handling and file system features. Its asynchronous and non-blocking I/O, buffer-oriented approach, and three fundamental components of buffers, channels, and selectors make it a unique I/O system.

Java NIO's non-blocking server model is able to handle multiple requests simultaneously by using non-blocking I/O pipes. Unlike blocking I/O pipes, the non-blocking model only checks and provides those SelectableChannel instances that actually have data to read, making it a faster and more efficient system.

The above is the detailed content of Non-blocking server in Java NIO. For more information, please follow other related articles on the PHP Chinese website!