面试题：Java AIO异常处理与线程模型的关系

1. Java AIO 与传统同步 I/O 异常处理的不同

传统同步 I/O：
- 在传统同步 I/O 中，当执行 I/O 操作（如 read 或 write）时，如果发生异常，异常会立即抛出，调用者可以在同一线程中捕获并处理该异常。例如：

try {
    FileInputStream fis = new FileInputStream("test.txt");
    int data;
    while ((data = fis.read()) != -1) {
        // 处理数据
    }
    fis.close();
} catch (IOException e) {
    e.printStackTrace();
}

异常处理相对直接，因为 I/O 操作在当前线程执行，异常抛出和处理都在同一上下文。
Java AIO：
- Java AIO 是异步的，I/O 操作在后台线程执行。当后台线程中的 AIO 任务发生异常时，不能像同步 I/O 那样直接在调用者线程中捕获异常。因为调用者线程不会阻塞等待 I/O 操作完成，异常发生在不同的线程上下文中。例如，使用 AsynchronousSocketChannel 进行异步读取：

AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer, null, new CompletionHandler<Integer, Void>() {
    @Override
    public void completed(Integer result, Void attachment) {
        // 处理读取结果
    }

    @Override
    public void failed(Throwable exc, Void attachment) {
        // 这里处理 AIO 操作失败的异常
        exc.printStackTrace();
    }
});

AIO 通过 CompletionHandler 接口的 failed 方法来处理异常，异常处理逻辑在 failed 方法中定义，与调用异步操作的代码不在同一执行路径。

2. 确保主线程感知并处理 AIO 异常且不影响其他异步任务

使用 Future 模式：
- 可以使用 Future 来获取异步任务的结果并处理异常。Future 提供了 get 方法，该方法会阻塞调用线程直到异步任务完成，如果异步任务发生异常，get 方法会抛出异常。例如：

AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
ByteBuffer buffer = ByteBuffer.allocate(1024);
Future<Integer> future = channel.read(buffer);
try {
    Integer result = future.get();
    // 处理读取结果
} catch (InterruptedException | ExecutionException e) {
    if (e instanceof ExecutionException) {
        Throwable cause = e.getCause();
        cause.printStackTrace();
    }
}

优点是主线程可以统一处理异常，但 get 方法会阻塞主线程，可能影响其他异步任务的并发执行。
使用 CompletionService：
- CompletionService 结合了 Executor 和 BlockingQueue 的功能，可以将异步任务提交到 Executor 中执行，任务完成后，其结果（或异常）会被放入 BlockingQueue 中。主线程可以从队列中获取已完成的任务结果，而不会阻塞等待特定任务完成。例如：

ExecutorService executor = Executors.newFixedThreadPool(10);
CompletionService<Integer> completionService = new ExecutorCompletionService<>(executor);
AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
ByteBuffer buffer = ByteBuffer.allocate(1024);
completionService.submit(() -> channel.read(buffer));
try {
    Future<Integer> future = completionService.take();
    Integer result = future.get();
    // 处理读取结果
} catch (InterruptedException | ExecutionException e) {
    if (e instanceof ExecutionException) {
        Throwable cause = e.getCause();
        cause.printStackTrace();
    }
} finally {
    executor.shutdown();
}

这样既可以让主线程感知并处理 AIO 任务的异常，又不会影响其他异步任务的执行，因为主线程可以按照任务完成的顺序从队列中获取结果，而不是阻塞等待特定任务。
自定义异常处理机制：
- 可以通过自定义一个全局的异常处理机制，在 CompletionHandler 的 failed 方法中，将异常信息发送到主线程的异常处理队列或使用事件总线等方式通知主线程。例如：

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class AIOExceptionHandling {
    private static final BlockingQueue<Throwable> exceptionQueue = new LinkedBlockingQueue<>();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            try {
                AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                channel.read(buffer, null, new CompletionHandler<Integer, Void>() {
                    @Override
                    public void completed(Integer result, Void attachment) {
                        // 处理读取结果
                    }

                    @Override
                    public void failed(Throwable exc, Void attachment) {
                        try {
                            exceptionQueue.put(exc);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                });
            } catch (Exception e) {
                try {
                    exceptionQueue.put(e);
                } catch (InterruptedException ex) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();

        while (true) {
            Throwable exception = exceptionQueue.take();
            exception.printStackTrace();
            // 在这里进行主线程对异常的处理
        }
    }
}

这种方式可以灵活地处理异常，并且不影响其他异步任务的执行，主线程可以根据自身逻辑从队列中获取异常并处理。

星途面试题库

面试题：Java AIO异常处理与线程模型的关系

知识考点

面试题答案

1. Java AIO 与传统同步 I/O 异常处理的不同

2. 确保主线程感知并处理 AIO 异常且不影响其他异步任务