免責聲明：本人最近在研讀《Netty實戰》書籍，對于里面內容頗感興趣，本文旨在于技術學習交流，不存在盈利性目的。

Java 網絡編程

BIO：block input output

早期的網絡編程開發人員，需要花費大量的時間去學習復雜的 C 語言套接字庫，去處理它們在不同的操作系統上出現的古怪問題。早期的 Java API（java.net）只支持由本地系統套接字庫提供的所謂的阻塞函數。Java創建一個復雜的客戶端/服務器協議需要大量的樣板代碼（以及相當多的底層研究才能使它整個流暢地運行起來）。早期Java阻塞 I/O 示例代碼：

ServerSocket serverSocket = new ServerSocket(portNumber);
Socket clientSocket = serverSocket.accept();
BufferedReader in = new BufferedReader(
    new InputStreamReader(clientSocket.getInputStream()));
    PrintWriter out =
        new PrintWriter(clientSocket.getOutputStream(), true);
    String request, response;
    while ((request = in.readLine()) != null) {
    if ("Done".equals(request)) {
        break;
    }
    response = processRequest(request);
    out.println(response);
    }

這段代碼片段將只能同時處理一個連接，要管理多個并發客戶端，需要為每個新的客戶端Socket 創建一個新的 Thread，對于這種模式，主要存在以下幾個問題：

第一，在任何時候都可能有大量的線程處于休眠狀態，只是等待輸入或者輸出數據就緒，這可能算是一種資源浪費。

第二，需要為每個線程的調用棧都分配內存，其默認值大小區間為 64 KB 到 1 MB，具體取決于操作系統。

第三，即使 Java 虛擬機（JVM）在物理上可以支持非常大數量的線程，但是遠在到達該極限之前，上下文切換所帶來的開銷就會帶來麻煩，例如，在達到 10 000 個連接的時候。雖然這種并發方案對于支撐中小數量的客戶端來說還算可以接受，但是為了支撐 100 000 或者更多的并發連接所需要的資源使得它很不理想。

這就是JAVA中典型的BIO模型，模型結構圖如下所示：

BIO 就是傳統的 java.io 包，它是基于流模型實現的，交互的方式是同步、阻塞方式，也就是說在讀入輸入流或者輸出流時，在讀寫動作完成之前，線程會一直阻塞在那里，它們之間的調用時可靠的線性順序。它的有點就是代碼比較簡單、直觀；缺點就是 IO 的效率和擴展性很低，容易成為應用性能瓶頸。

NIO：Non-blocking input output

NIO 是 Java 1.4 引入的 java.nio 包，提供了 Channel、Selector、Buffer 等新的抽象，可以構建多路復用的、同步非阻塞 IO 程序，同時提供了更接近操作系統底層高性能的數據操作方式。

新的還是非阻塞的

NIO 最開始是新的輸入/輸出（New Input/Output）的英文縮寫，但是，該Java API 已經出現足夠長的時間了，不再是“新的”了，因此，如今大多數的用戶認為NIO 代表非阻塞 I/O（Non-blocking I/O），而阻塞I/O（blocking  I/O）是舊的輸入/輸出（old input/output，OIO）。你也可能遇到它被稱為普通I/O（plain I/O）的時候。

Java NIO的核心組件 包括：

• 通道（Channel）
• 緩沖區（Buffer）
• 選擇器（Selectors）

NIO具體實現代碼示例：

基于通道 & 緩沖數據

    // 1. 獲取數據源 和 目標傳輸地的輸入輸出流（此處以數據源 = 文件為例）
    FileInputStream fin = new FileInputStream(infile);
    FileOutputStream fout = new FileOutputStream(outfile);

    // 2. 獲取數據源的輸入輸出通道
    FileChannel fcin = fin.getChannel();
    FileChannel fcout = fout.getChannel();

    // 3. 創建 緩沖區 對象：Buffer（共有2種方法）
     // 方法1：使用allocate()靜態方法
     ByteBuffer buff = ByteBuffer.allocate(256);
     // 上述方法創建1個容量為256字節的ByteBuffer
     // 注：若發現創建的緩沖區容量太小，則重新創建一個大小合適的緩沖區

    // 方法2：通過包裝一個已有的數組來創建
     // 注：通過包裝的方法創建的緩沖區保留了被包裝數組內保存的數據
     ByteBuffer buff = ByteBuffer.wrap(byteArray);

     // 額外：若需將1個字符串存入ByteBuffer，則如下
     String sendString="你好,服務器. ";
     ByteBuffer sendBuff = ByteBuffer.wrap(sendString.getBytes("UTF-16"));

    // 4. 從通道讀取數據 & 寫入到緩沖區
    // 注：若 以讀取到該通道數據的末尾，則返回-1
    fcin.read(buff);

    // 5. 傳出數據準備：將緩存區的寫模式 轉換->> 讀模式
    buff.flip();

    // 6. 從 Buffer 中讀取數據 & 傳出數據到通道
    fcout.write(buff);

    // 7. 重置緩沖區
    // 目的：重用現在的緩沖區,即 不必為了每次讀寫都創建新的緩沖區，在再次讀取之前要重置緩沖區
    // 注：不會改變緩沖區的數據，只是重置緩沖區的主要索引值
    buff.clear();

基于選擇器（Selecter）

// 1. 創建Selector對象   
Selector sel = Selector.open();

// 2. 向Selector對象綁定通道   
 // a. 創建可選擇通道，并配置為非阻塞模式   
 ServerSocketChannel server = ServerSocketChannel.open();   
 server.configureBlocking(false);   
 
 // b. 綁定通道到指定端口   
 ServerSocket socket = server.socket();   
 InetSocketAddress address = new InetSocketAddress(port);   
 socket.bind(address);   
 
 // c. 向Selector中注冊感興趣的事件   
 server.register(sel, SelectionKey.OP_ACCEPT);    
 return sel;

// 3. 處理事件
try {    
    while(true) { 
        // 該調用會阻塞，直到至少有一個事件就緒、準備發生 
        selector.select(); 
        // 一旦上述方法返回，線程就可以處理這些事件
        Set<SelectionKey> keys = selector.selectedKeys(); 
        Iterator<SelectionKey> iter = keys.iterator(); 
        while (iter.hasNext()) { 
            SelectionKey key = (SelectionKey) iter.next(); 
            iter.remove(); 
            process(key); 
        }    
    }    
} catch (IOException e) {    
    e.printStackTrace();   
}

class java.nio.channels.Selector 是Java 的非阻塞 I/O 實現的關鍵。它使用了事件通知 API以確定在一組非阻塞套接字中有哪些已經就緒能夠進行 I/O 相關的操作。因為可以在任何的時間檢查任意的讀操作或者寫操作的完成狀態，個單一的線程便可以處理多個并發的接。

總體來看，與阻塞 I/O 模型相比，這種模型提供了更好的資源管理：

1. 使用較少的線程便可以處理許多連接，因此也減少了內存管理和上下文切換所帶來開銷；
2. 當沒有 I/O 操作需要處理的時候，線程也可以被用于其他任務。

盡管已經有許多直接使用 Java NIO API 的應用程序被構建了，但是要做到如此正確和安全并不容易。特別是，在高負載下可靠和高效地處理和調度 I/O 操作是一項繁瑣而且容易出錯的任務，最好留給高性能的網絡編程專家——Netty。

Netty 簡介

Netty 是一款用于創建高性能網絡應用程序的高級框架。是一款異步的事件驅動的網絡應用程序框架，支持快速地開發可維護的高性能的面向協議的服務器和客戶端。在網絡編程領域，Netty是Java的卓越框架。它駕馭了Java高級API的能力，并將其隱藏在一個易于使用的API之后。Netty使你可以專注于自己真正感興趣的——你的應用程序的獨一無二的價值。

異步和事件驅動

異步也就是非同步，本質上，一個既是異步的又是事件驅動的系統會表現出一種特殊的、對我們來說極具價值的行為：它可以以任意的順序響應在任意的時間點產生的事件。這種能力對于實現最高級別的可伸縮性至關重要，定義為：“一種系統、網絡或者進程在需要處理的工作不斷增長時，可以通過某種可行的方式或者擴大它的處理能力來適應這種增長的能力。”

• 同步交互：指發送一個請求,需要等待返回,然后才能夠發送下一個請求，有個等待過程；

• 異步交互：指發送一個請求,不需要等待返回,隨時可以再發送下一個請求，即不需要等待。 區別：一個需要等待，一個不需要等待，在部分情況下，我們的項目開發中都會優先選擇不需要等待的異步交互方式。

• netty 是事件驅動的，這里面有兩個含義，一是 netty 接收到 socket 數據后，會產生事件，事件在 pipeline 上傳播，二是事件由特定的線程池處理。

異步和可伸縮性之間的聯系又是什么呢？

• 非阻塞網絡調用使得我們可以不必等待一個操作的完成。完全異步的 I/O 正是基于這個特性構建的，并且更進一步：異步方法會立即返回，并且在它完成時，會直接或者在稍后的某個時間點通知用戶。
• 選擇器使得我們能夠通過較少的線程便可監視許多連接上的事件。

將這些元素結合在一起，與使用阻塞 I/O 來處理大量事件相比，使用非阻塞 I/O 來處理更快速、更經濟。從網絡編程的角度來看，這是構建我們理想系統的關鍵，這也是Netty 的設計底蘊的關鍵。