请解释 Java 中的 IO 和 NIO 的区别，以及 NIO 如何实现多路复用?

Java中的IO和NIO是两种不同的输入输出处理方式，它们在设计理念、实现方式、性能特点和应用场景上有着显著的差异。

下面我将详细解释Java中的IO和NIO的区别，以及NIO如何实现多路复用，并提供一些日常开发中的使用建议和注意事项。

Java中的IO和NIO的区别

1. 面向流与面向缓冲

Java IO：面向流的处理方式，基于传统的阻塞式输入输出模型。数据以顺序的方式流动，且在读写过程中，一般情况下会阻塞当前线程，直到操作完成。

// Java IO示例：读取文件内容
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class FileIOExample {public static void main(String[] args) {String filePath = "example.txt";try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {String line;while ((line = br.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();}}
}

Java NIO：面向缓冲区的处理方式，数据读取到一个缓冲区，需要时可在缓冲区中前后移动。这增加了处理过程中的灵活性。

// Java NIO示例：读取文件内容
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;public class FileNIOExample {public static void main(String[] args) {String filePath = "example.txt";try {Files.lines(Paths.get(filePath)).forEach(System.out::println);} catch (IOException e) {e.printStackTrace();}}
}

2. 阻塞与非阻塞IO

Java IO：各种流是阻塞的，当一个线程调用read()或write()时，该线程被阻塞，直到数据传输完成。

// Java IO示例：阻塞式读取数据
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;public class BlockingIOExample {public static void main(String[] args) {try (InputStream inputStream = new FileInputStream("example.txt")) {byte[] buffer = new byte[1024];int bytesRead;while ((bytesRead = inputStream.read(buffer)) != -1) {System.out.write(buffer, 0, bytesRead);}} catch (IOException e) {e.printStackTrace();}}
}

Java NIO：支持非阻塞模式，当一个通道没有数据可读时，线程可以继续处理其他事情，而不是阻塞在原地等待。

// Java NIO示例：非阻塞式读取数据
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.io.IOException;public class NonBlockingNIOExample {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);int bytesRead;while ((bytesRead = fileChannel.read(buffer)) != -1) {buffer.flip();while (buffer.hasRemaining()) {System.out.print((char) buffer.get());}buffer.clear();}} catch (IOException e) {e.printStackTrace();}}
}

3. 选择器（Selectors）

Java IO：没有选择器的概念，每个连接需要独立的线程进行处理。

Java NIO：通过Selector实现单线程管理多个Channel，通过select调用，可以获取已经准备好的Channel并进行相应的处理。

// Java NIO示例：使用Selector实现多路复用
import java.io.IOException;
import java.net.InetSocketAddress;
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;public class NIOServer {public static void main(String[] args) throws IOException {Selector selector = Selector.open();ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();serverSocketChannel.bind(new InetSocketAddress(8080));serverSocketChannel.configureBlocking(false);serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);while (true) {int readyChannels = selector.select();if (readyChannels == 0) continue;Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();while (keyIterator.hasNext()) {SelectionKey key = keyIterator.next();if (key.isAcceptable()) {ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();SocketChannel clientChannel = serverChannel.accept();clientChannel.configureBlocking(false);clientChannel.register(selector, SelectionKey.OP_READ);} else if (key.isReadable()) {SocketChannel clientChannel = (SocketChannel) key.channel();ByteBuffer buffer = ByteBuffer.allocate(1024);int bytesRead = clientChannel.read(buffer);if (bytesRead > 0) {buffer.flip();while (buffer.hasRemaining()) {System.out.print((char) buffer.get());}buffer.clear();}}keyIterator.remove();}}}
}

NIO如何实现多路复用

NIO通过Selector实现多路复用，Selector允许一个线程同时监控多个Channel。当一个Channel有事件发生时，Selector会通知相应的线程进行处理。这就大大减少了线程的开销，让系统能够在高并发场景下保持高效。

Selector的工作原理

注册事件：应用程序将多个Channel注册到Selector上，通常注册的是感兴趣的事件，比如读(OP_READ)、写(OP_WRITE)等。
事件等待：在应用程序调用selector.select()方法时，Selector会阻塞，直到有通道准备好进行某种操作。此时，它会检查是否有通道处于就绪状态。
事件分发：一旦某个Channel准备好操作，Selector会返回一个包含所有就绪事件的集合。应用程序可以遍历这个集合，针对每个就绪的Channel执行相应的读写操作。
事件处理：处理完相关的事件后，应用程序可以选择继续等待，或者再次注册其他事件。

示例代码

import java.io.IOException;
import java.net.InetSocketAddress;
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;public class NIOServer {public static void main(String[] args) throws IOException {Selector selector = Selector.open();ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();serverSocketChannel.bind(new InetSocketAddress(8080));serverSocketChannel.configureBlocking(false);serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);while (true) {int readyChannels = selector.select();if (readyChannels == 0) continue;Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();while (keyIterator.hasNext()) {SelectionKey key = keyIterator.next();if (key.isAcceptable()) {ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();SocketChannel clientChannel = serverChannel.accept();clientChannel.configureBlocking(false);clientChannel.register(selector, SelectionKey.OP_READ);} else if (key.isReadable()) {SocketChannel clientChannel = (SocketChannel) key.channel();ByteBuffer buffer = ByteBuffer.allocate(1024);int bytesRead = clientChannel.read(buffer);if (bytesRead > 0) {buffer.flip();while (buffer.hasRemaining()) {System.out.print((char) buffer.get());}buffer.clear();}}keyIterator.remove();}}}
}

日常开发中的使用建议和注意事项

选择合适的IO模型：
- 对于简单的数据交互，如文件读写、小规模网络通信等，可以使用传统的IO。
- 对于高并发、需要高性能的场景，如服务器开发、大数据处理等，建议使用NIO。
合理使用缓冲区：
- 在NIO中，缓冲区（Buffer）是数据读写的核心。合理使用缓冲区可以提高数据处理的效率。
- 注意缓冲区的状态管理，如flip、clear、compact等操作，确保数据正确读写。
处理异常和资源释放：
- 在IO操作中，务必处理IOException，确保程序的健壮性。
- 使用try-with-resources语句或finally块确保资源正确释放，避免内存泄漏。
避免过度优化：
- 在选择IO模型时，不要过度优化。对于简单的任务，使用传统的IO可能更加方便和高效。
- 只有在确实需要高性能时，才考虑使用NIO或NIO 2。