Java NIO 新 IO 與傳統 IO 有何不同

Java NIO（New IO）與傳統IO（也稱為阻塞式IO或BIO，Blocking IO）之間存在幾個關鍵的區別：

1. 阻塞與非阻塞

• 傳統IO（BIO）：

  • 是阻塞式的，當一個線程調用read()或write()方法時，該線程會被阻塞，直到數據被完全讀取或寫入。
  • 這意味著在等待I/O操作完成期間，線程不能執行其他任務。

• Java NIO（New IO）：

  • 提供了非阻塞模式，允許線程在等待I/O操作完成時執行其他任務。
  • 通過使用Selector，一個線程可以管理多個通道（Channel），從而實現高效的I/O多路復用。

2. 面向流與面向緩沖

• 傳統IO（BIO）：

  • 是面向流的，數據以字節流或字符流的形式逐個處理。
  • 每次讀取或寫入操作都是基于流的，沒有緩沖區的概念。

• Java NIO（New IO）：

  • 是面向緩沖的，數據首先被讀取到緩沖區中，然后再從緩沖區中處理。
  • 緩沖區提供了更靈活的數據處理方式，并且可以提高I/O操作的效率。

3. 選擇器（Selector）

• 傳統IO（BIO）：

  • 沒有選擇器的概念，每個連接都需要一個單獨的線程來處理。

• Java NIO（New IO）：

  • 引入了選擇器，允許單個線程管理多個通道。
  • 選擇器可以監視多個通道的事件（如連接、讀取、寫入），并在事件發生時通知應用程序。

4. 性能

• 傳統IO（BIO）：

  • 在高并發場景下，由于每個連接都需要一個線程，線程數量會迅速增加，導致系統資源消耗過大，性能下降。

• Java NIO（New IO）：

  • 通過非阻塞模式和選擇器，可以在高并發場景下更高效地處理I/O操作，減少線程數量，提高系統性能。

5. 適用場景

• 傳統IO（BIO）：

  • 適用于連接數較少且每個連接的處理時間較長的場景。
  • 例如，文件傳輸、簡單的HTTP請求等。

• Java NIO（New IO）：

  • 適用于高并發、低延遲的場景。
  • 例如，聊天服務器、實時數據處理等。

示例代碼

傳統IO（BIO）

import java.io.*;
import java.net.*;

public class BIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        while (true) {
            Socket clientSocket = serverSocket.accept();
            new Thread(() -> {
                try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                     PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
                    String request;
                    while ((request = in.readLine()) != null) {
                        out.println("Echo: " + request);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Java NIO（New IO）

import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;

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) {
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();
            while (iter.hasNext()) {
                SelectionKey key = iter.next();

                if (key.isAcceptable()) {
                    handleAccept(key, selector);
                } else if (key.isReadable()) {
                    handleRead(key);
                }

                iter.remove();
            }
        }
    }

    private static void handleAccept(SelectionKey key, Selector selector) throws IOException {
        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverSocketChannel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.register(selector, SelectionKey.OP_READ);
    }

    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = clientChannel.read(buffer);
        if (bytesRead > 0) {
            buffer.flip();
            byte[] data = new byte[buffer.remaining()];
            buffer.get(data);
            String request = new String(data).trim();
            System.out.println("Received: " + request);
            clientChannel.write(ByteBuffer.wrap(("Echo: " + request).getBytes()));
        } else if (bytesRead == -1) {
            clientChannel.close();
        }
    }
}

通過上述對比和示例代碼，可以看出Java NIO在處理高并發I/O操作時具有顯著的優勢。