Java 网络编程：Socket 与 NIO 对比

网络编程是 Java 开发中的核心技能，从传统的阻塞式 IO（BIO）到非阻塞式 IO（NIO），底层逻辑决定了应用的性能上限。理解两者的差异与实现步骤，是构建高性能服务的基础。

核心模型差异

传统的 Socket（BIO）采用“一连接一线程”模型，如同餐厅的服务员一对一服务顾客，若顾客思考不出菜名，服务员只能原地等待，资源浪费严重。NIO 采用“选择器”模型，如同餐厅服务员手持对讲机同时监控多张桌子，只有当顾客真正举手示意（发生事件）时，服务员才上前处理，极大地提升了并发处理能力。

Socket (BIO) 实战步骤

在连接数较少且固定的场景下，Socket 编程简单直观，调试容易。以下是构建一个基础 Socket 服务端的操作流程。

1. 创建 服务端套接字对象，指定监听端口。
   实例化 ServerSocket 类，并传入端口号，例如 9999。此时 JVM 会向操作系统申请绑定该端口。

   ServerSocket serverSocket = new ServerSocket(9999);

2. 阻塞等待 客户端连接。
   调用 accept() 方法。程序运行到此行时会进入阻塞状态，直到有客户端发起连接。该方法返回一个 Socket 对象，代表与客户端的连接通道。

   Socket socket = serverSocket.accept();

3. 获取 输入输出流。
   通过 Socket 对象 获取 InputStream 读取客户端数据，获取 OutputStream 向客户端发送数据。这是数据交换的管道。

   InputStream in = socket.getInputStream();
   OutputStream out = socket.getOutputStream();

4. 读写 数据并处理逻辑。
   使用 字节数组或缓冲流 读取 数据。注意，read() 方法也是阻塞的，如果客户端未发送数据或连接未关闭，线程会卡在此处。

   byte[] buffer = new byte[1024];
   int len = in.read(buffer); // 阻塞点
   String msg = new String(buffer, 0, len);

5. 关闭 资源。
   处理完毕后，必须关闭 Socket、输入流和输出流，释放系统资源。通常建议在 finally 代码块中执行此操作。

NIO 实战步骤

NIO 引入了 Channel（通道）、Buffer（缓冲区）和 Selector（选择器）三个核心组件。以下是基于 NIO 构建服务端的标准化流程。

1. 分配 缓冲区。
   使用 ByteBuffer.allocate() 分配 指定大小的内存块。Buffer 是 NIO 读写数据的载体，所有数据必须先放入 Buffer。

   ByteBuffer buffer = ByteBuffer.allocate(1024);

2. 开启 服务端通道。
   调用 ServerSocketChannel.open() 创建 通道对象。这相当于打开了文件描述符，但尚未绑定地址。

   ServerSocketChannel serverChannel = ServerSocketChannel.open();

3. 配置 非阻塞模式。
   调用 configureBlocking(false) 设置 通道为非阻塞状态。若省略此步，默认行为将与 BIO 一致，失去 NIO 意义。

   serverChannel.configureBlocking(false);

4. 绑定 端口。
   调用 bind() 方法，将通道绑定到特定的 IP 地址和端口。

   serverChannel.bind(new InetSocketAddress(8888));

5. 创建 选择器并注册通道。
   实例化 Selector.open()。调用 register() 方法将服务端通道注册到选择器，并 指定 监听事件为 SelectionKey.OP_ACCEPT（连接就绪事件）。

   Selector selector = Selector.open();
   serverChannel.register(selector, SelectionKey.OP_ACCEPT);

6. 循环轮询 就绪事件。
   编写 死循环，调用 selector.select() 方法。该方法会阻塞，直到至少有一个通道的事件就绪。

   while (true) {
       if (selector.select() > 0) {
           // 有事件发生
       }
   }

7. 遍历 就绪事件集合。
   获取 selectedKeys() 集合，使用 迭代器遍历。判断 事件的类型（是连接就绪 OP_ACCEPT 还是读就绪 OP_READ）。

   Set<SelectionKey> selectedKeys = selector.selectedKeys();
   Iterator<SelectionKey> iterator = selectedKeys.iterator();
   while (iterator.hasNext()) {
       SelectionKey key = iterator.next();
       // 处理逻辑...
       iterator.remove(); // 移除已处理的事件
   }

8. 处理 具体业务逻辑。
   若 key.isAcceptable() 为真，执行 接收连接操作，并将新连接的 SocketChannel 注册到 Selector 监听 OP_READ。若 key.isReadable() 为真，从 Channel 读取 数据到 Buffer。

关键技术点对比

理解两者的技术细节差异，有助于在正确的场景选择正确的工具。

Buffer 的核心操作

NIO 中数据的读写严重依赖 Buffer 的状态翻转。以下是操作 Buffer 时的铁律。

1. 写入 数据到 Buffer。
   执行 channel.read(buffer) 或 buffer.put(data)。此时 position 指针向后移动。

2. 切换 读取模式。
   必须调用 flip() 方法。此操作将 limit 设置为当前 position，并将 position 重置为 0。如果不调用此方法，后续读取将读到空数据或越界。

   buffer.flip(); // 核心翻转操作

3. 读取 Buffer 数据。
   执行 buffer.get() 或 channel.write(buffer)。

4. 清除 或 重置 Buffer。
   读取完毕后，调用 clear() 方法（重置所有指针）或 compact() 方法（压缩未读数据），为下一次写入做准备。

选型决策路径

在实际开发中，根据业务需求选择模型至关重要。

1. 评估 连接数规模。
   若预估并发连接数小于 1000，且服务器资源充足，直接选择 Socket (BIO)。开发成本低，维护简单。

2. 判断 业务逻辑复杂度。
   若连接数超过万级，且业务主要是短连接或 IO 密集型（如即时通讯、推送服务），必须选择 NIO。

3. 考虑 使用框架。
   如果决定使用 NIO，强烈建议 使用 Netty 等成熟框架。原生 NIO API 极其复杂，存在 Epoll 空轮询 Bug，直接使用风险极高。Netty 封装了 Selector 和 Buffer 操作，提供了更安全的 API。