MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java NIO 的异常处理技巧

2024-06-252.7k 阅读

Java NIO 概述

在深入探讨 Java NIO 的异常处理技巧之前，我们先来简要回顾一下 Java NIO。Java NIO（New I/O）是从 Java 1.4 开始引入的一套新的 I/O 类库，它提供了一种基于通道（Channel）和缓冲区（Buffer）的 I/O 操作方式，与传统的基于流（Stream）的 I/O 相比，具有更高的效率和灵活性。

通道与缓冲区

通道（Channel）是一种可以进行读写操作的对象，类似于传统 I/O 中的流，但它更加灵活和强大。例如，FileChannel 用于文件的读写操作，SocketChannel 用于 TCP 套接字的读写，DatagramChannel 用于 UDP 数据报的读写。

缓冲区（Buffer）则是一个用于存储数据的容器，所有的数据操作都通过缓冲区来进行。常见的缓冲区类型有 ByteBuffer、CharBuffer、IntBuffer 等。

Java NIO 的优势

  1. 非阻塞 I/O：Java NIO 支持非阻塞 I/O 操作，这意味着在进行 I/O 操作时，线程不会被阻塞，从而可以更高效地利用系统资源。例如，在使用 Selector 时，一个线程可以同时监控多个通道的 I/O 事件，大大提高了系统的并发处理能力。
  2. 内存映射文件：通过 MappedByteBuffer，可以将文件直接映射到内存中，使得对文件的读写操作就像对内存的操作一样高效，尤其适用于处理大文件。

Java NIO 异常类型

在 Java NIO 编程中，可能会遇到多种类型的异常，了解这些异常类型对于正确处理异常至关重要。

IOException 及其子类

  1. FileNotFoundException：当试图打开一个不存在的文件时，FileChannel.open() 方法可能会抛出 FileNotFoundException。例如：
import java.io.FileNotFoundException;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileChannelExample {
    public static void main(String[] args) {
        Path path = Paths.get("nonexistentfile.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            // 文件操作
        } catch (FileNotFoundException e) {
            System.err.println("文件未找到: " + e.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. IOException：这是一个通用的 I/O 异常，涵盖了许多 I/O 操作失败的情况，如读取或写入文件时出错、网络连接中断等。例如，在使用 SocketChannel 进行网络通信时，如果连接被中断，可能会抛出 IOException：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class SocketChannelExample {
    public static void main(String[] args) {
        try (SocketChannel socketChannel = SocketChannel.open()) {
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
            ByteBuffer buffer = ByteBuffer.wrap("Hello, Server!".getBytes());
            socketChannel.write(buffer);
            buffer.clear();
            socketChannel.read(buffer);
            System.out.println("从服务器接收到: " + new String(buffer.array()));
        } catch (IOException e) {
            System.err.println("I/O 操作出错: " + e.getMessage());
        }
    }
}

ClosedChannelException

当试图对一个已经关闭的通道进行操作时，会抛出 ClosedChannelException。例如，在关闭 FileChannel 后再次尝试读取数据：

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class ClosedChannelExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            fileChannel.close();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            fileChannel.read(buffer); // 这里会抛出 ClosedChannelException
        } catch (IOException e) {
            System.err.println("通道已关闭: " + e.getMessage());
        }
    }
}

AsynchronousCloseException

如果一个通道在进行异步 I/O 操作时被关闭，可能会抛出 AsynchronousCloseException。例如，在使用 Future 进行异步 I/O 操作时，如果在操作完成前关闭通道：

import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class AsynchronousCloseExample {
    public static void main(String[] args) {
        try (AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open()) {
            Future<Integer> future = socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
            try {
                future.get(); // 等待连接完成
                ByteBuffer buffer = ByteBuffer.wrap("Hello".getBytes());
                Future<Integer> writeFuture = socketChannel.write(buffer);
                socketChannel.close(); // 在写入完成前关闭通道
                try {
                    writeFuture.get(); // 这里可能会抛出 AsynchronousCloseException
                } catch (ExecutionException | InterruptedException e) {
                    System.err.println("异步操作异常: " + e.getMessage());
                }
            } catch (ExecutionException | InterruptedException e) {
                System.err.println("连接异常: " + e.getMessage());
            }
        } catch (IOException e) {
            System.err.println("I/O 异常: " + e.getMessage());
        }
    }
}

CancelledKeyException

在使用 Selector 时，如果一个 SelectionKey 被取消，并且试图使用该 SelectionKey 进行操作，会抛出 CancelledKeyException。例如：

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class CancelledKeyExample {
    public static void main(String[] args) {
        try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
             Selector selector = Selector.open()) {
            serverSocketChannel.bind(new java.net.InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                int readyChannels = selector.select();
                if (readyChannels == 0) continue;
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();
                    if (key.isAcceptable()) {
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        SocketChannel client = server.accept();
                        client.configureBlocking(false);
                        client.register(selector, SelectionKey.OP_READ);
                    } else if (key.isReadable()) {
                        SocketChannel client = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        client.read(buffer);
                        buffer.flip();
                        System.out.println("接收到: " + new String(buffer.array()));
                        key.cancel(); // 取消该 SelectionKey
                        try {
                            client.write(ByteBuffer.wrap("Response".getBytes())); // 这里会抛出 CancelledKeyException
                        } catch (CancelledKeyException e) {
                            System.err.println("SelectionKey 已取消: " + e.getMessage());
                        }
                    }
                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

其他异常

  1. IllegalArgumentException：当传递给方法的参数不合法时，可能会抛出 IllegalArgumentException。例如，在创建 ByteBuffer 时，如果指定的容量为负数：
import java.nio.ByteBuffer;

public class IllegalArgumentExceptionExample {
    public static void main(String[] args) {
        try {
            ByteBuffer buffer = ByteBuffer.allocate(-10); // 这里会抛出 IllegalArgumentException
        } catch (IllegalArgumentException e) {
            System.err.println("参数不合法: " + e.getMessage());
        }
    }
}
  1. ReadOnlyBufferException：当试图对只读缓冲区进行写入操作时，会抛出 ReadOnlyBufferException。例如：
import java.nio.ByteBuffer;

public class ReadOnlyBufferExample {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.wrap(new byte[]{1, 2, 3});
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
        try {
            readOnlyBuffer.put((byte) 4); // 这里会抛出 ReadOnlyBufferException
        } catch (ReadOnlyBufferException e) {
            System.err.println("只读缓冲区不能写入: " + e.getMessage());
        }
    }
}

Java NIO 异常处理技巧

正确捕获异常

  1. 分层捕获：在处理 Java NIO 异常时，建议采用分层捕获的方式。外层捕获较通用的异常，如 IOException，内层捕获特定的异常，这样可以更精确地处理不同类型的错误。例如：
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class LayeredExceptionHandling {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        try {
            try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                fileChannel.read(buffer);
                buffer.flip();
                System.out.println("读取到: " + new String(buffer.array()));
            } catch (FileNotFoundException e) {
                System.err.println("文件未找到: " + e.getMessage());
            } catch (IOException e) {
                System.err.println("文件读取 I/O 错误: " + e.getMessage());
            }
        } catch (Exception e) {
            System.err.println("其他异常: " + e.getMessage());
        }
    }
}
  1. 避免捕获不必要的异常：不要捕获 Throwable，除非你真的需要处理所有可能的错误，包括 Error 类型的错误。通常情况下，只捕获 Exception 及其子类即可。例如：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class AvoidThrowableCapture {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            fileChannel.read(buffer);
            buffer.flip();
            System.out.println("读取到: " + new String(buffer.array()));
        } catch (IOException e) {
            System.err.println("I/O 异常: " + e.getMessage());
        }
    }
}

异常日志记录

  1. 详细记录异常信息：在捕获异常时，要详细记录异常的堆栈跟踪信息和错误消息，以便于调试和排查问题。可以使用日志框架，如 log4j 或 java.util.logging。例如，使用 java.util.logging：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ExceptionLogging {
    private static final Logger logger = Logger.getLogger(ExceptionLogging.class.getName());

    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            fileChannel.read(buffer);
            buffer.flip();
            System.out.println("读取到: " + new String(buffer.array()));
        } catch (IOException e) {
            logger.log(Level.SEVERE, "文件读取失败", e);
        }
    }
}
  1. 区分不同级别的日志：根据异常的严重程度，记录不同级别的日志。例如，对于 FileNotFoundException 可以记录为 Level.WARNING，而对于严重的 IOException 可以记录为 Level.SEVERE。
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;

public class LeveledExceptionLogging {
    private static final Logger logger = Logger.getLogger(LeveledExceptionLogging.class.getName());

    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            fileChannel.read(buffer);
            buffer.flip();
            System.out.println("读取到: " + new String(buffer.array()));
        } catch (FileNotFoundException e) {
            logger.log(Level.WARNING, "文件未找到", e);
        } catch (IOException e) {
            logger.log(Level.SEVERE, "文件读取 I/O 错误", e);
        }
    }
}

资源清理

  1. 使用 try - with - resources：在 Java 7 及以上版本，使用 try - with - resources 语句可以确保在异常发生时，相关的资源（如通道）能够被正确关闭。例如：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            fileChannel.read(buffer);
            buffer.flip();
            System.out.println("读取到: " + new String(buffer.array()));
        } catch (IOException e) {
            System.err.println("I/O 异常: " + e.getMessage());
        }
    }
}
  1. 手动清理资源：在 Java 7 之前，需要手动在 finally 块中关闭资源。例如：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class ManualResourceCleanup {
    public static void main(String[] args) {
        FileChannel fileChannel = null;
        try {
            Path path = Paths.get("example.txt");
            fileChannel = FileChannel.open(path, StandardOpenOption.READ);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            fileChannel.read(buffer);
            buffer.flip();
            System.out.println("读取到: " + new String(buffer.array()));
        } catch (IOException e) {
            System.err.println("I/O 异常: " + e.getMessage());
        } finally {
            if (fileChannel != null) {
                try {
                    fileChannel.close();
                } catch (IOException e) {
                    System.err.println("关闭文件通道出错: " + e.getMessage());
                }
            }
        }
    }
}

异常恢复策略

  1. 重试机制：对于一些由于临时网络故障或资源暂时不可用导致的异常，可以采用重试机制。例如，在网络连接失败时，可以尝试多次重新连接：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class RetryExample {
    private static final int MAX_RETRIES = 3;

    public static void main(String[] args) {
        int retries = 0;
        while (retries < MAX_RETRIES) {
            try (SocketChannel socketChannel = SocketChannel.open()) {
                socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
                ByteBuffer buffer = ByteBuffer.wrap("Hello, Server!".getBytes());
                socketChannel.write(buffer);
                buffer.clear();
                socketChannel.read(buffer);
                System.out.println("从服务器接收到: " + new String(buffer.array()));
                break;
            } catch (IOException e) {
                retries++;
                System.err.println("连接失败，重试次数: " + retries + " 错误信息: " + e.getMessage());
            }
        }
        if (retries == MAX_RETRIES) {
            System.err.println("达到最大重试次数，连接失败");
        }
    }
}
  1. 降级策略：当某些高级功能因为异常无法使用时，可以采用降级策略，使用较为基础的功能替代。例如，在使用 MappedByteBuffer 进行文件操作时，如果因为内存不足等原因抛出异常，可以切换回传统的文件读写方式：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class DegradationStrategyExample {
    public static void main(String[] args) {
        File file = new File("example.txt");
        try (FileChannel fileChannel = new FileOutputStream(file).getChannel()) {
            try {
                MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);
                mappedByteBuffer.put("Hello, World!".getBytes());
            } catch (IOException e) {
                System.err.println("使用 MappedByteBuffer 出错，切换到传统方式");
                try (FileOutputStream fos = new FileOutputStream(file);
                     FileInputStream fis = new FileInputStream(file)) {
                    ByteBuffer buffer = ByteBuffer.wrap("Hello, World!".getBytes());
                    fos.write(buffer.array());
                    buffer.clear();
                    fis.read(buffer.array());
                    buffer.flip();
                    System.out.println("读取到: " + new String(buffer.array()));
                } catch (IOException ex) {
                    System.err.println("传统文件操作也出错: " + ex.getMessage());
                }
            }
        } catch (IOException e) {
            System.err.println("文件操作出错: " + e.getMessage());
        }
    }
}

多线程环境下的异常处理

线程池中的异常处理

  1. submit 方法与 Future：当使用 ExecutorService 的 submit 方法提交任务时，任务中的异常不会直接抛出，而是可以通过 Future 的 get 方法获取。例如：
import java.util.concurrent.*;

public class ThreadPoolExceptionHandlingWithSubmit {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Future<Integer> future = executorService.submit(() -> {
            if (Math.random() < 0.5) {
                throw new RuntimeException("模拟异常");
            }
            return 42;
        });
        try {
            Integer result = future.get();
            System.out.println("任务结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            System.err.println("任务执行异常: " + e.getMessage());
        } finally {
            executorService.shutdown();
        }
    }
}
  1. execute 方法与 UncaughtExceptionHandler：使用 ExecutorService 的 execute 方法提交任务时，如果任务抛出未捕获的异常，可以通过设置 Thread.UncaughtExceptionHandler 来处理。例如：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExceptionHandlingWithExecute {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
            System.err.println("线程 " + t.getName() + " 抛出未捕获异常: " + e.getMessage());
        });
        executorService.execute(() -> {
            if (Math.random() < 0.5) {
                throw new RuntimeException("模拟异常");
            }
            System.out.println("任务执行成功");
        });
        executorService.shutdown();
    }
}

多线程共享资源的异常处理

  1. 同步块中的异常处理：当多个线程共享 Java NIO 资源（如 FileChannel）时，在同步块中进行异常处理非常重要，以避免资源不一致。例如：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class SharedResourceExceptionHandling {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Path path = Paths.get("sharedFile.txt");
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ_WRITE)) {
                    ByteBuffer buffer = ByteBuffer.wrap("Thread 1 writes".getBytes());
                    fileChannel.write(buffer);
                } catch (IOException e) {
                    System.err.println("线程 1 I/O 异常: " + e.getMessage());
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    fileChannel.read(buffer);
                    buffer.flip();
                    System.out.println("线程 2 读取到: " + new String(buffer.array()));
                } catch (IOException e) {
                    System.err.println("线程 2 I/O 异常: " + e.getMessage());
                }
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            System.err.println("线程中断异常: " + e.getMessage());
        }
    }
}
  1. 使用 ReentrantLock：除了 synchronized 关键字，还可以使用 ReentrantLock 来同步多线程对共享资源的访问，并在异常处理时正确释放锁。例如：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExceptionHandling {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Path path = Paths.get("sharedFile.txt");
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ_WRITE)) {
                    ByteBuffer buffer = ByteBuffer.wrap("Thread 1 writes".getBytes());
                    fileChannel.write(buffer);
                } catch (IOException e) {
                    System.err.println("线程 1 I/O 异常: " + e.getMessage());
                }
            } finally {
                lock.unlock();
            }
        });
        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    fileChannel.read(buffer);
                    buffer.flip();
                    System.out.println("线程 2 读取到: " + new String(buffer.array()));
                } catch (IOException e) {
                    System.err.println("线程 2 I/O 异常: " + e.getMessage());
                }
            } finally {
                lock.unlock();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            System.err.println("线程中断异常: " + e.getMessage());
        }
    }
}

性能与异常处理

异常对性能的影响

  1. 异常抛出的开销：抛出异常是一个相对昂贵的操作，因为它涉及到创建异常对象、填充堆栈跟踪信息等操作。在 Java NIO 中，如果频繁抛出异常，会对性能产生较大影响。例如，在一个循环中频繁抛出 IOException：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class ExceptionPerformanceImpact {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
                // 假设这里经常抛出异常
                throw new IOException("模拟异常");
            } catch (IOException e) {
                // 异常处理
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("执行时间: " + (endTime - startTime) + " 毫秒");
    }
}
  1. 避免不必要的异常：在编写 Java NIO 代码时，应尽量避免在正常流程中抛出异常。例如，可以通过提前检查条件来避免 IllegalArgumentException 等异常。例如：
import java.nio.ByteBuffer;

public class AvoidUnnecessaryException {
    public static void main(String[] args) {
        int capacity = 10;
        if (capacity > 0) {
            ByteBuffer buffer = ByteBuffer.allocate(capacity);
            // 正常操作
        } else {
            System.err.println("容量不能为负数");
        }
    }
}

优化异常处理以提升性能

  1. 减少异常捕获范围：尽量缩小异常捕获块的范围，只在可能抛出异常的代码段周围捕获异常，这样可以减少异常处理对性能的影响。例如：
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class NarrowExceptionCapture {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            try {
                fileChannel.read(buffer);
                buffer.flip();
                System.out.println("读取到: " + new String(buffer.array()));
            } catch (IOException e) {
                System.err.println("文件读取 I/O 错误: " + e.getMessage());
            }
        } catch (IOException e) {
            System.err.println("打开文件 I/O 错误: " + e.getMessage());
        }
    }
}
  1. 使用条件判断替代异常：对于一些可以通过条件判断提前处理的情况，使用条件判断而不是依赖异常处理。例如，在检查文件是否存在时：
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class ConditionalCheckInsteadOfException {
    public static void main(String[] args) {
        Path path = Paths.get("example.txt");
        File file = path.toFile();
        if (file.exists()) {
            try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                fileChannel.read(buffer);
                buffer.flip();
                System.out.println("读取到: " + new String(buffer.array()));
            } catch (IOException e) {
                System.err.println("文件读取 I/O 错误: " + e.getMessage());
            }
        } else {
            System.err.println("文件不存在");
        }
    }
}

通过以上对 Java NIO 异常处理技巧的详细介绍，包括异常类型、处理方法、多线程环境下的处理以及性能优化等方面，希望能帮助开发者在编写 Java NIO 程序时，更加稳健地处理异常，提高程序的可靠性和性能。