【面试宝典】40道Java IO高频题库整理(附答案背诵版)

1、什么是同步IO和异步IO？请简述它们的区别。

同步 I/O（Input/Output）和异步 I/O 是两种基本的数据交换模式。

同步 I/O (Synchronous I/O):

在同步 I/O 模式中，一个 I/O 操作必须在完成之前，其他所有的操作都必须等待。也就是说，一个同步 I/O 操作阻止了程序的执行，直到这个操作完成。这种方式简单、直接，但也容易造成程序阻塞，降低了程序的整体效率。

例如，当你在 Java 中使用 FileInputStream 读取文件时，如果文件非常大，那么程序会阻塞，直到整个文件都被读取完毕。

异步 I/O (Asynchronous I/O):

在异步 I/O 模式中，一个 I/O 操作的开始和结束（或完成）是分离的。也就是说，当一个异步 I/O 操作开始后，程序可以继续执行其他操作，而不需要等待这个 I/O 操作完成。当这个 I/O 操作完成时，程序会收到一个通知。

例如，Java NIO（Non-blocking I/O）就是一种异步 I/O 模式。当你使用 java.nio.channels.AsynchronousFileChannel 读取文件时，你可以传递一个 CompletionHandler 参数。当文件读取完成时，CompletionHandler 的 completed 方法会被自动调用。

同步 I/O 与异步 I/O 的主要区别:

同步和异步操作的主要区别在于程序是否需要等待 I/O 操作完成。同步 I/O 操作在完成之前会阻止程序的其余部分继续执行，而异步 I/O 操作则允许程序在 I/O 操作完成之前继续执行其他任务。这种能力使得异步 I/O 在处理大量并发 I/O 操作时，例如在大规模网络服务器或高性能计算应用中，可以提供更高的效率。

2、在Java中如何实现异步IO操作？

在 Java 中，异步 I/O 主要通过 NIO（New Input/Output）库实现，尤其是 NIO.2，这是在 Java 7 中引入的，提供了异步文件 I/O 操作的支持。

要在 Java 中实现异步 I/O 操作，可以使用 java.nio.channels 包中的 AsynchronousFileChannel 类或者对于网络操作使用 AsynchronousSocketChannel 和 AsynchronousServerSocketChannel 类。这些类提供了异步操作的能力，允许你在进行大型 I/O 操作时，继续进行其他任务。

下面是一个简单的异步文件读取操作的例子，使用了 AsynchronousFileChannel：

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

public class AsyncIOExample {
   
   

    public static void main(String[] args) {
   
   
        Path path = Paths.get("path/to/file.txt");

        try (AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
   
   
            
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            Future<Integer> operation = fileChannel.read(buffer, 0);

            // 你可以继续做其他工作，当读操作完成后处理结果
            while (!operation.isDone()) {
   
   
                // 执行一些其他任务
            }

            // 读取完成后，你可以处理数据
            int bytesRead = operation.get();  // 阻塞直到读取完成
            System.out.println("Read " + bytesRead + " bytes");
            
            // 操作 buffer 中的数据...
            
        } catch (Exception ex) {
   
   
            System.err.println(ex);
        }
    }
}

在这个例子中，我们首先打开一个 AsynchronousFileChannel 对象，然后启动一个异步读操作。通过 Future 对象，我们可以检查操作是否完成，并且在操作完成后获取结果。注意，这里的 operation.get() 方法会阻塞，直到异步读取操作完成。如果你想要非阻塞地获取结果，可以在调用 get() 方法之前使用 isDone() 方法检查操作是否已经完成。

另一种方式是使用回调，通过实现 CompletionHandler 接口，你可以在操作完成时异步地得到通知：

fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
   
   
    @Override
    public void completed(Integer result, ByteBuffer attachment) {
   
   
        System.out.println("Read " + result + " bytes");
        // 操作 buffer 中的数据...
    }

    @Override
    public void failed(Throwable exc, ByteBuffer attachment) {
   
   
        System.err.println(exc);
    }
});

使用回调的方式，你可以完全非阻塞地处理 I/O，这在编写大规模并发应用时特别有用。

3、什么是阻塞IO？请举一个阻塞IO的例子。

阻塞 I/O 指的是 I/O 操作会阻塞调用线程直到操作完成。在阻塞 I/O 模型中，一个线程发起了 I/O 操作后，必须等待数据读取或者写入完成才能继续执行其他操作。如果 I/O 请求不能立即完成，线程会一直等待，直到有数据可以处理或者是 I/O 操作真的完成。

这种模型在处理单个连接时很简单和直接，但是它不能很好地扩展到大量并发连接，因为每个 I/O 操作都可能导致线程阻塞，这意味着需要更多的线程来处理其他并发任务，而线程资源是有限且代价昂贵的。

阻塞 I/O 的例子：

下面是 Java 中使用 FileInputStream 和 BufferedReader 的例子，这是一个标准的阻塞 I/O 操作的例子。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BlockingIOExample {
   
   
    public static void main(String[] args) {
   
   
        // 使用 BufferedReader 读取文件内容
        try (BufferedReader reader = new BufferedReader(new FileReader("path/to/file.txt"))) {
   
   
            String line;
            while ((line = reader.readLine()) != null) {
   
   
                // 处理每一行数据
                S