What is asynchronous I/O in Java?

Asynchronous I/O in Java is a way of handling input and output operations that allow an application to perform I/O operations without being blocked, but instead performing other tasks in the background. With asynchronous I/O, applications can handle a large number of concurrent requests in an efficient and non-blocking manner.

In the traditional synchronous I/O model, when an application initiates an I/O request, it is blocked until the I/O operation completes and a result is returned. In this process, the CPU is unable to perform other tasks, which can lead to a decrease in system performance. In contrast, the asynchronous I/O model allows an application to continue performing other tasks after an I/O request has been made, without having to wait for the I/O operation to complete.

Java provides support for asynchronous I/O, primarily through a number of classes and methods in the Java NIO (New I/O) library. Among them, the most important are the java.nio.channels.AsynchronousChannel interface and the java.nio.channels.CompletionHandler interface.

The Asynchronous Channel interface represents a channel that can perform asynchronous I/O operations, and it provides a way to read and write data asynchronously. By calling these methods, the application can initiate an I/O request and return immediately without having to wait for the operation to complete.

The CompletionHandler interface defines the callback method when the I/O operation is completed. When the I/O operation is completed, the system calls the relevant callback method and passes the result of the operation as a parameter to the callback method. With the callback method, the application can process the results of the I/O operation and move on to other tasks.

Here's a real-world example of using asynchronous I/O, assuming we need to download an image from multiple URLs and do some processing after the download is complete:

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;

public class AsyncIOExample {
    public static void main(String[] args) throws Exception {
        String[] urls = { "https://example.com/image1.jpg", "https://example.com/image2.jpg", "https://example.com/image3.jpg" };

        for (String url : urls) {
            downloadImage(url);
        }

        // 后续处理
        // ...
    }

    private static void downloadImage(String url) throws Exception {
        Path path = Path.of("images/", url.substring(url.lastIndexOf('/') + 1));

        AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(
                path, StandardOpenOption.CREATE, StandardOpenOption.WRITE);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .build();

        CompletionHandler<Integer, ByteBuffer> completionHandler = new CompletionHandler<>() {
            @Override
            public void completed(Integer result, ByteBuffer buffer) {
                buffer.flip();
                try {
                    Future<Integer> writeResult = fileChannel.write(buffer, 0);
                    writeResult.get(); // 等待写入完成
                } catch (Exception e) {
                    e.printStackTrace();
                }
                buffer.clear();

                // 下载完成后的处理
                // ...
            }

            @Override
            public void failed(Throwable exc, ByteBuffer buffer) {
                exc.printStackTrace();
            }
        };

        ByteBuffer buffer = ByteBuffer.allocate(1024 * 8);

        client.sendAsync(request, HttpResponse.BodyHandlers.ofPublisher())
                .thenApply(HttpResponse::body)
                .thenAccept(body -> {
                    body.subscribe(buffer::put, completionHandler::failed, () -> completionHandler.completed(-1, buffer));
                });
    }
}
           

In the example above, we download multiple images via asynchronous I/O and save them to the local file system. In the downloadImage method, we use AsynchronousFileChannel to open a file channel and initiate an HTTP request to get the image data. In the callback method of the HTTP response, we write the image data to the file channel and do some processing after the write is complete.

Asynchronous I/O in Java provides a way to efficiently handle input and output operations. By using asynchronous I/O, we can continue to perform other tasks without being blocked while I/O is being performed. This is useful for applications that need to handle a large number of concurrent requests or that require high response performance.