请解释 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 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的工作原理

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

示例代码

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 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();
            }
        }
    }
}

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

1. 选择合适的IO模型：

   • 对于简单的数据交互，如文件读写、小规模网络通信等，可以使用传统的IO。
   • 对于高并发、需要高性能的场景，如服务器开发、大数据处理等，建议使用NIO。

2. 合理使用缓冲区：

   • 在NIO中，缓冲区（Buffer）是数据读写的核心。合理使用缓冲区可以提高数据处理的效率。
   • 注意缓冲区的状态管理，如flip、clear、compact等操作，确保数据正确读写。

3. 处理异常和资源释放：

   • 在IO操作中，务必处理IOException，确保程序的健壮性。
   • 使用try-with-resources语句或finally块确保资源正确释放，避免内存泄漏。

4. 避免过度优化：

   • 在选择IO模型时，不要过度优化。对于简单的任务，使用传统的IO可能更加方便和高效。
   • 只有在确实需要高性能时，才考虑使用NIO或NIO 2。

通过理解Java中的IO和NIO的区别，以及NIO如何实现多路复用，开发者可以根据具体需求选择合适的IO模型，从而提高程序的性能和效率。