Netty學習前基本知識—BIO 、NIO 、AIO 總結

作者：一角錢技術 2020-10-10 19:37:27

熟練掌握 BIO、NIO、AIO 的基本概念以及一些常見問題是你準備面試的過程中不可或缺的一部分，另外這些知識點也是你學習 Netty 的基礎。

基本概念
IO模型就是說用什么樣的通道進行數據的發送和接收，Java 共支持3中網絡變成 IO 模式：BIO、NIO、AIO。Java 中的 BIO、NIO 和 AIO 理解為是 Java 語言對操作系統的各種 IO 模型的封裝。我們在使用這些 API 的時候，不需要關系操作系統層面的知識，也不需要根據不同操作系統編寫不同的代碼。

在講 BIO、NIO、AIO 之前先回顧幾個概念：同步與異步、阻塞與非阻塞、I/O模型。

同步與異步

同步：同步就是發起一個調用后，被調用者未處理完請求之前，調用不返回。
異步：異步就是發一個調用后，立刻得到被調用者的回應表示已接收到請求，但是被調用者并沒有返回結果，此時可以處理其他的請求，被調用者通常依靠事件、回調等機制來通知調用者其返回結果。

同步和異步的區別最大在于異步的話調用者不需要等待結果處理，被調用者會通過回調等機制來通知調用者返回結果。

阻塞和非阻塞

阻塞：阻塞就是發起一個請求，調用者一直等待請求結果返回，也就是當前線程會被掛起，無法從事其他任務，只有當條件就緒才能繼續。
非阻塞：非阻塞就是發起一個請求，調用者不用一直等著結果返回，可以先去干其他的事情。

同步異步與阻塞非阻塞（段子）
老張燒開水的故事（故事來源網絡）

老張愛喝茶，廢話不說，煮開水。

出場人物：老張，水壺兩把（普通水壺，簡稱水壺；會響的水壺，簡稱響水壺）。

1.老張把水壺放到火上，立等水開。（同步阻塞）
老張覺得自己有點傻

2.老張把水壺放到火上，去客廳看電視，時不時去廚房看看水開沒有。（同步非阻塞）
老張還是覺得自己有點傻，于是變高端了，買了把會響笛的那種水壺。水開之后，能大聲發出嘀~~的噪音。

3.老張把響水壺放到火上，立等水開。（異步阻塞）
老張覺得這樣傻等意義不大

4.老張把響水壺放到火上，去客廳看電視，水壺響之前不再去看它了，響了再去拿壺。（異步非阻塞）
老張覺得自己聰明了。

所謂同步異步，只是對于水壺而言

普通水壺：同步；響水壺：異步。
雖然都能干活，但響水壺可以在自己完工之后，提示老張水開了，這是普通水壺所不能及的。
同步只能讓調用者去輪詢自己（情況2中），造成老張效率的低下。

所謂阻塞非阻塞，僅僅對于老張而言

立等的老張：阻塞；看電視的老張：非阻塞。
情況1 和情況3 中老張就是阻塞的，媳婦喊他都不知道。雖然情況3中響水壺是異步的，可對于立等的老張沒有太大的意義。所以一般異步是配合非阻塞使用的，這樣才能發揮異步的效用。

常見的 I/O 模型對比
所有的系統 I/O 都分為兩個階段：等待就緒和操作。

舉例來說，讀函數，分為等待系統可讀和真正的讀；同理，寫函數分為等待網卡可以寫和真正的寫。

需要說明的是等待就緒的阻塞是不使用 CPU 的，是在“空等”；而真正的讀操作的阻塞是使用 CPU 的，真正在“干活”，而且這個過程非常快，屬于 memory copy，帶寬通常在 1GB/s 級別以上，可以理解為基本不耗時。

如下幾種常見 I/O 模型的對比：

以socket.read()為例子：

傳統的BIO里面socket.read()，如果TCP RecvBuffer里沒有數據，函數會一直阻塞，直到收到數據，返回讀到的數據。
對于NIO，如果TCP RecvBuffer有數據，就把數據從網卡讀到內存，并且返回給用戶；反之則直接返回0，永遠不會阻塞。
AIO(Async I/O)里面會更進一步：不但等待就緒是非阻塞的，就連數據從網卡到內存的過程也是異步的。

換句話說，BIO里用戶最關心“我要讀”，NIO里用戶最關心"我可以讀了"，在AIO模型里用戶更需要關注的是“讀完了”。

NIO一個重要的特點是：socket主要的讀、寫、注冊和接收函數，在等待就緒階段都是非阻塞的，真正的I/O操作是同步阻塞的（消耗CPU但性能非常高）。

BIO（Blocking I/O）
同步阻塞 I/O 模式，數據的讀取寫入必須阻塞在一個線程內等待其完成（一個客戶端連接對于一個處理線程）。

傳統 BIO
BIO通信（一請求一應答）模型圖如下(圖源網絡)：

采用 BIO 通信模型的服務隊，通常由一個獨立的 Acceptor 線程負責監聽客戶端的連接。我們一般通過在 while(true) 循環中服務端會調用 accept() 方法等待客戶端連接的方式監聽請求，請求一旦接收到一個連接請求，就可以建立通信套接字在這個通信套接字上進行讀寫操作，此時不能再接收其他客戶端連接請求，只能等待當前連接的客戶端的操作執行完成，不過可以通過多線程來支持多個客戶端的連接，如上圖所示。

如果要讓 BIO 通信模型能夠同時處理多個客戶端的請求，就必須使用多線程（要原因是 socket.accept()、 socket.read()、 socket.write() 涉及的三個主要函數都是同步阻塞的），當一個連接在處理 I/O 的時候，系統是阻塞的，如果是單線程的必然就掛死在哪里。開啟多線程，就可以讓CPU去處理更多的事情。也就是說它在接收到客戶端連接請求之后為每個客戶端創建一個新的線程進行鏈路處理，處理完成之后，通過輸出流返回給客戶端，線程銷毀。這就是典型的一請求一應答通信模型。

其實這也是所有使用多線程的本質：

利用多核
當 I/O 阻塞系統，但 CPU 空閑的時候，可以利用多線程使用 CPU 資源。

我們可以設想以下如果連接不做任何的事情的話就會造成不必要的線程開銷，不過可以通過線程池機制改善，線程池還可以讓線程的創建和回收成本相對較低。例如使用FixedTreadPool 可以有效的控制來線程的最大數量，保證來系統有限的資源的控制，實現了N（客戶端請求數量）：M（處理客戶端請求的線程數量）的偽異步I/O模型（N可以遠遠大于M）。

我們再設想以下當客戶端并發訪問量增加后這種模型會出什么問題？隨著并發訪問量增加會導致線程數急劇膨脹可能會導致線程堆棧溢出、創建新線程失敗等問題，最終導致進程宕機或者僵死，不能對外提供服務。

在Java虛擬機中，線程是寶貴的資源，主要體現在：

1.線程的創建和銷毀成本很高，尤其在 Linux 操作系統中，線程本質上就是一個進程，創建和銷毀線程都是重量級的系統函數；
2.線程本身占用較大內存，像 Java 的線程棧，一般至少分配 512k～1M 的空間，如果系統中的線程數過千，恐怕整個 JVM 的內存都會被吃掉一半；
3.線程的切換成本也很高。操作系統發生線程切換的時候，需要保留線程的上下文，然后執行系統調用。如果線程數過高，可能執行線程切換的時間甚至會大于線程執行的時間，這時候帶來的表現往往是系統load偏高，CPU sy 使用率特別高（超過20%以上），導致系統幾乎陷入不可用的狀態；
4.容易造成鋸齒狀的系統負載。因為系統的負載是用活動線程數和CPU核心數，一旦線程數量高但外部網絡環境不是很穩定，就很容易造成大量請求的結果同時返回，激活大量阻塞線程從而使系統負載壓力過大。 Linux系統中CPU中sy過高> sy的值表示是內核的消耗，如果出現sy的值過高，不要先去考慮是內核的問題，先查看是不是內存不足，是不是磁盤滿，是不是IO的問題，就是說先考慮自己進程的問題，比方是否IO引起的問題，是否網絡引起的問題的。排查系統IO或者網絡等是否已經到瓶頸了。
偽異步 I/O
為了解決同步阻塞I/O面臨的一個鏈路需要一個線程處理的問題，后來有人對它的線程模型進行了優化：后端通過一個線程池來處理多個客戶端的請求接入，形成客戶端個數M：線程池最大線程數N的比例關系，其中M可以遠遠大于N.通過線程池可以靈活地調配線程資源，設置線程的最大值，防止由于海量并發接入導致線程耗盡。

偽異步IO模型圖(圖源網絡)

采用線程池和任務隊列可以實現一種叫做偽異步的 I/O 通信框架，它的模型圖如上圖所示。當有新的客戶端接入時，將客戶端的 Socket 封裝成一個Task（該任務實現java.lang.Runnable接口）投遞到后端的線程池中進行處理，JDK 的線程池維護一個消息隊列和 N 個活躍線程，對消息隊列中的任務進行處理。由于線程池可以設置消息隊列的大小和最大線程數，因此，它的資源占用是可控的，無論多少個客戶端并發訪問，都不會導致資源的耗盡和宕機。

偽異步I/O通信框架采用了線程池實現，因此避免了為每個請求都創建一個獨立線程造成的線程資源耗盡問題。不過因為它的底層仍然是同步阻塞的BIO模型，因此無法從根本上解決問題。

缺點

IO 代碼里 read 操作是阻塞操作，如果連接不做數據讀寫操作會導致線程阻塞，浪費資源；
如果線程很多，會導致服務器線程太多，壓力太大。

應用場景
BIO 方式適用于連接數目比較小且固定的架構，這種方式對服務器資源要求比較高，但程序簡單理解。

BIO 代碼示例
服務端

package com.niuh.bio; 
import java.io.IOException; 
import java.net.ServerSocket;import java.net.Socket;public class SocketServer {    public static void main(String[] args) throws IOException {        ServerSocket serverSocket = new ServerSocket(9000); 
        while (true) { 
            System.out.println("等待連接。。"); 
            //阻塞方法            final Socket socket = serverSocket.accept();            System.out.println("有客戶端連接了。。"); 
            // 多線程處理            new Thread(new Runnable() {                @Override                public void run() {                    try {                        handler(socket);                    } catch (IOException e) {                        e.printStackTrace();                    }                }            }).start();            // 單線程處理            //handler(socket);        }    }    private static void handler(Socket socket) throws IOException {        System.out.println("thread id = " + Thread.currentThread().getId()); 
        byte[] bytes = new byte[1024]; 
        System.out.println("準備read。。"); 
        //接收客戶端的數據，阻塞方法，沒有數據可讀時就阻塞        int read = socket.getInputStream().read(bytes); 
        System.out.println("read完畢。。"); 
        if (read != -1) { 
            System.out.println("接收到客戶端的數據：" + new String(bytes, 0, read)); 
            System.out.println("thread id = " + Thread.currentThread().getId()); 
        }        socket.getOutputStream().write("HelloClient".getBytes()); 
        socket.getOutputStream().flush(); 
    }}

客戶端

package com.niuh.bio; 
import java.io.IOException; 
import java.net.Socket; 
public class SocketClient { 
    public static void main(String[] args) throws IOException { 
        Socket socket = new Socket("127.0.0.1", 9000); 
        //向服務端發送數據 
        socket.getOutputStream().write("HelloServer".getBytes()); 
        socket.getOutputStream().flush(); 
        System.out.println("向服務端發送數據結束"); 
        byte[] bytes = new byte[1024]; 
        //接收服務端回傳的數據 
        socket.getInputStream().read(bytes); 
        System.out.println("接收到服務端的數據：" + new String(bytes)); 
        socket.close(); 
    } 
}

NIO（Non Blocking IO）
同步非阻塞，服務器實現模式為一個線程可以處理多個請求（連接），客戶端發送的連接請求都會注冊到多路復用器 selector 上，多路復用器輪詢到連接有 IO 請求就進行處理。

它支持面向緩沖的，基于通道的I/O操作方法。NIO提供了與傳統BIO模型中的 Socket 和 ServerSocket 相對應的 SocketChannel 和 ServerSocketChannel 兩種不同的套接字通道實現，兩種通道都支持阻塞和非阻塞兩種模式。

阻塞模式使用就像傳統中的支持一樣，比較簡單，但是性能和可靠性都不好；
非阻塞模式正好與之相反。

對于低負載、低并發的應用程序，可以使用同步阻塞I/O來提升開發速率和更好的維護性；對于高負載、高并發的（網絡）應用，應使用 NIO 的非阻塞模式來開發。

NIO核心組件
NIO 有三大核心組件：

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

整個NIO體系包含的類遠遠不止這三個，只能說這三個是NIO體系的“核心API”。

channel 類似于流，每個 channel 對應一個 buffer 緩沖區，buffer 底層就是個數組；
channel 會注冊到 selector 上，由 selector 根據 channel 讀寫事件的發生將其交由某個空閑的線程處理；
selector 可以對應一個或多個線程
NIO 的 Buffer 和 channel 既可以讀也可以寫

NIO的特性
我們從一個問題來總結：NIO 與 IO 的區別？

如果是在面試中來回答這個問題，我覺得首先肯定要從 NIO 流是非阻塞 IO，而 IO 流是阻塞 IO說起。然后可以從 NIO 的3個核心組件/特性為 NIO 帶來的一些改進來分析。

IO流是阻塞的，NIO流不是阻塞的
Java NIO 使我們可以進行非阻塞 IO 操作。比如說，單線程中從通道讀取數據到 buffer，同時可以繼續做別的事情，當數據讀取到 buffer 中后，線程再繼續處理數據。寫數據也是一樣的。另外，非阻塞寫也是日常，一個線程請求寫入一些數據到某通道，但不需要等待它完全寫入，這個線程同時可以去做別的事情。

Java IO 的各種流是阻塞的，這意味著，當一個線程調用 read() 或 write() 時，該線程被阻塞，直到有一些數據被讀取或數據完全寫入。該線程在此期間不能再干任何事情了。

IO 面向流（Stream oriented），NIO 面向緩沖區（Buffer oriented）
Buffer（緩沖區）

Buffer 是一個對象，它包含一些要寫入或者要讀出的數據。在 NIO 類庫中加入 Buffer對象，體現了新庫與原庫 I/O的一個重要區別：

在面向流的 I/O 中，可以直接將數據寫入或者將數據直接讀到 Stream 對象中。雖然 Stream 中也有 Buffer 開通的擴展類，但只是流的包裝類，還從流讀到緩沖區。
NIO 是直接讀到 Buffer 中進行操作。在 NIO 庫中，所有的數據都是用緩沖區處理的。在讀取數據時，它是直接讀到緩沖區中的；在寫入數據時，寫入到緩存中。任何時候訪問 NIO 中的數據，都是通過緩沖區進行操作。

最常用的緩沖區是 ByteBuffer，ByteBuffer 提供流一組功能用于操作 byte 數組。除了 ByteBuffer 還有其他的一些緩沖區，事實上，每一種 Java 基本類型（除了 Boolean 類型）都對應有一種緩沖區。

NIO 通過 Channel（通道）進行讀寫
Channel（通道）

通道是雙向的，可讀也可以寫，而流的讀寫是單向的。無論讀寫，通道只能和 Buffer 交互。因為 Buffer，通道可以異步地讀寫。

NIO 有選擇器，而 IO 沒有
Selectors（選擇器）

選擇器用于使用單線程處理多個通道。因此，它需要較少的線程來處理這些通道。線程之間的切換對于操作系統來說是昂貴的。因此，為了提供系統效率選擇器是有用的。

NIO 讀數據和寫數據
通常來說 NIO 中的所有 IO 都是從 Channel（通道）開始的。

從通道進行數據讀取：創建一個緩沖區，然后請求通道讀取數據；
從通道進行數據寫入：創建一個緩沖區，填充數據，并要求通道寫入數據。

數據讀取和寫入操作如下：

應用場景
NIO 方式適用于連接數目多且連接比較短（輕操作）的架構，比如聊天服務器、彈幕系統、服務器間通訊、編程比較復雜。

NIO 代碼示例
服務端

package com.niuh.nio; 
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 ExecutorService pool = Executors.newFixedThreadPool(10); 
    public static void main(String[] args) throws IOException {        // 創建一個在本地端口進行監聽的服務Socket通道.并設置為非阻塞方式        ServerSocketChannel ssc = ServerSocketChannel.open(); 
        //必須配置為非阻塞才能往selector上注冊，否則會報錯，selector模式本身就是非阻塞模式        ssc.configureBlocking(false); 
        ssc.socket().bind(new InetSocketAddress(9000)); 
        // 創建一個選擇器selector        Selector selector = Selector.open(); 
        // 把ServerSocketChannel注冊到selector上，并且selector對客戶端accept連接操作感興趣        ssc.register(selector, SelectionKey.OP_ACCEPT);        while (true) { 
            System.out.println("等待事件發生。。"); 
            // 輪詢監聽channel里的key，select是阻塞的，accept()也是阻塞的 
            int select = selector.select(); 
            System.out.println("有事件發生了。。"); 
            // 有客戶端請求，被輪詢監聽到            Iterator<SelectionKey> it = selector.selectedKeys().iterator();            while (it.hasNext()) { 
                SelectionKey key = it.next(); 
                //刪除本次已處理的key，防止下次select重復處理 
                it.remove(); 
                handle(key);            }        }    }    private static void handle(SelectionKey key) throws IOException {        if (key.isAcceptable()) { 
            System.out.println("有客戶端連接事件發生了。。"); 
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();            //NIO非阻塞體現：此處accept方法是阻塞的，但是這里因為是發生了連接事件，所以這個方法會馬上執行完，不會阻塞            //處理完連接請求不會繼續等待客戶端的數據發送            SocketChannel sc = ssc.accept();            sc.configureBlocking(false); 
            //通過Selector監聽Channel時對讀事件感興趣            sc.register(key.selector(), SelectionKey.OP_READ);        } else if (key.isReadable()) { 
            System.out.println("有客戶端數據可讀事件發生了。。"); 
            SocketChannel sc = (SocketChannel) key.channel();            ByteBuffer buffer = ByteBuffer.allocate(1024); 
            //NIO非阻塞體現:首先read方法不會阻塞，其次這種事件響應模型，當調用到read方法時肯定是發生了客戶端發送數據的事件 
            int len = sc.read(buffer); 
            if (len != -1) { 
                System.out.println("讀取到客戶端發送的數據：" + new String(buffer.array(), 0, len)); 
            }            ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes()); 
            sc.write(bufferToWrite); 
            key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);        } else if (key.isWritable()) { 
            SocketChannel sc = (SocketChannel) key.channel();            System.out.println("write事件"); 
            // NIO事件觸發是水平觸發            // 使用Java的NIO編程的時候，在沒有數據可以往外寫的時候要取消寫事件，            // 在有數據往外寫的時候再注冊寫事件            key.interestOps(SelectionKey.OP_READ);            //sc.close(); 
        }    }}

NIO服務端程序詳細分析：

創建一個 ServerSocketChannel 和 Selector ，并將 ServerSocketChannel 注冊到 Selector 上；
Selector 通過 select() 方法監聽 channel 事件，當客戶端連接時，selector 監聽到連接事件，獲取到 ServerSocketChannel 注冊時綁定的 selectionKey；
selectionKey 通過 channel() 方法可以獲取綁定的 ServerSocketChannel；
ServerSocketChannel 通過 accept() 方法得到 SocketChannel;
將 SocketChannel 注冊到 Selector 上，關心 read 事件；
注冊后返回一個 SelectionKey，會和該 SocketChannel 關聯；
Selector 繼續通過 select() 方法監聽事件，當客戶端發送數據給服務端，Selector 監聽到 read 事件，獲取到 SocketChannel 注冊時綁定的 SelectionKey;
SelectionKey 通過 channel() 方法可以獲取綁定的 socketChannel;
將 socketChannel 里的數據讀取出來；
用 socketChannel 將服務端數據寫回客戶端。

客戶端

package com.niuh.nio; 
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.SocketChannel;import java.util.Iterator;public class NioClient { 
    //通道管理器 
    private Selector selector; 
    /**     * 啟動客戶端測試     *     * @throws IOException     */ 
    public static void main(String[] args) throws IOException { 
        NioClient client = new NioClient(); 
        client.initClient("127.0.0.1", 9000); 
        client.connect(); 
    } 
    /** 
     * 獲得一個Socket通道，并對該通道做一些初始化的工作     *     * @param ip   連接的服務器的ip     * @param port 連接的服務器的端口號     * @throws IOException     */ 
    public void initClient(String ip, int port) throws IOException { 
        // 獲得一個Socket通道 
        SocketChannel channel = SocketChannel.open(); 
        // 設置通道為非阻塞 
        channel.configureBlocking(false); 
        // 獲得一個通道管理器 
        this.selector = Selector.open(); 
        // 客戶端連接服務器,其實方法執行并沒有實現連接，需要在listen（）方法中調 
        //用channel.finishConnect() 才能完成連接 
        channel.connect(new InetSocketAddress(ip, port)); 
        //將通道管理器和該通道綁定，并為該通道注冊SelectionKey.OP_CONNECT事件。 
        channel.register(selector, SelectionKey.OP_CONNECT); 
    } 
    /** 
     * 采用輪詢的方式監聽selector上是否有需要處理的事件，如果有，則進行處理     *     * @throws IOException     */ 
    public void connect() throws IOException { 
        // 輪詢訪問selector 
        while (true) { 
            selector.select(); 
            // 獲得selector中選中的項的迭代器 
            Iterator<SelectionKey> it = this.selector.selectedKeys().iterator(); 
            while (it.hasNext()) { 
                SelectionKey key = (SelectionKey) it.next(); 
                // 刪除已選的key,以防重復處理 
                it.remove(); 
                // 連接事件發生 
                if (key.isConnectable()) { 
                    SocketChannel channel = (SocketChannel) key.channel(); 
                    // 如果正在連接，則完成連接 
                    if (channel.isConnectionPending()) { 
                        channel.finishConnect(); 
                    } 
                    // 設置成非阻塞 
                    channel.configureBlocking(false); 
                    //在這里可以給服務端發送信息哦 
                    ByteBuffer buffer = ByteBuffer.wrap("HelloServer".getBytes()); 
                    channel.write(buffer); 
                    //在和服務端連接成功之后，為了可以接收到服務端的信息，需要給通道設置讀的權限。 
                    channel.register(this.selector, SelectionKey.OP_READ);                                            // 獲得了可讀的事件 
                } else if (key.isReadable()) { 
                    read(key); 
                } 
            } 
        } 
    } 
    /** 
     * 處理讀取服務端發來的信息 的事件     *     * @param key     * @throws IOException     */ 
    public void read(SelectionKey key) throws IOException { 
        //和服務端的read方法一樣 
        // 服務器可讀取消息:得到事件發生的Socket通道 
        SocketChannel channel = (SocketChannel) key.channel(); 
        // 創建讀取的緩沖區 
        ByteBuffer buffer = ByteBuffer.allocate(1024); 
        int len = channel.read(buffer); 
        if (len != -1) { 
            System.out.println("客戶端收到信息：" + new String(buffer.array(), 0, len)); 
        } 
    } 
}

總結
NIO 模型的 selector 就像一個大總管，負責監聽各種 I/O 事件，然后轉交給后端線程去處理。

NIO 相對于 BIO 非阻塞的體現就在：BIO 的后端線程需要阻塞等待客戶端寫數據（比如 read 方法），如果客戶端不寫數據線程就要阻塞。

NIO 把等到客戶端操作的時候交給了大總管 selector ，selector 負責輪詢所有已注冊的客戶端，發現有事件發生了才轉交給后端線程處理，后端線程不需要做任何阻塞等待，直接處理客戶端事件的數據即可，處理完馬上結束，或返回線程池供其他客戶端事件繼續使用。還有就是 channel 的讀寫是非阻塞的。

Redis 就是典型的 NIO 線程模型，selector 收集所有的事件并且轉給后端線程，線程連續執行所有事件命令并將結果寫回客戶端。

AIO（Asynchronous I/O）
異步非阻塞，由操作系統完成后回調通知服務端程序啟動線程去處理，一般適用于連接數較多且連接時間較長的應用。

AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改進版 NIO 2,它是異步非阻塞的IO模型。異步 IO 是基于事件和回調機制實現的，也就是應用操作之后會直接返回，不會堵塞在那里，當后臺處理完成，操作系統會通知相應的線程進行后續的操作。

AIO 是異步IO的縮寫，雖然 NIO 在網絡操作中，提供了非阻塞的方法，但是 NIO 的 IO 行為還是同步的。對于 NIO 來說，我們的業務線程是在 IO 操作準備好時，得到通知，接著就由這個線程自行進行 IO 操作，IO操作本身是同步的。（除了 AIO 其他的 IO 類型都是同步的）

應用場景
AIO 方式適用于連接數目多且連接比較長（重操作）的架構。

AIO 代碼示例
服務端

package com.niuh.aio; 
import java.io.IOException; 
import java.net.InetSocketAddress; 
import java.nio.ByteBuffer; 
import java.nio.channels.AsynchronousServerSocketChannel; 
import java.nio.channels.AsynchronousSocketChannel; 
import java.nio.channels.CompletionHandler; 
public class AIOServer { 
    public static void main(String[] args) throws Exception { 
        final AsynchronousServerSocketChannel serverChannel = 
                AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000)); 
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() { 
            @Override 
            public void completed(final AsynchronousSocketChannel socketChannel, Object attachment) { 
                try { 
                    // 再此接收客戶端連接，如果不寫這行代碼后面的客戶端連接連不上服務端 
                    serverChannel.accept(attachment, this); 
                    System.out.println(socketChannel.getRemoteAddress()); 
                    ByteBuffer buffer = ByteBuffer.allocate(1024); 
                    socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() { 
                        @Override 
                        public void completed(Integer result, ByteBuffer buffer) { 
                            buffer.flip(); 
                            System.out.println(new String(buffer.array(), 0, result)); 
                            socketChannel.write(ByteBuffer.wrap("HelloClient".getBytes())); 
                        } 
                        @Override 
                        public void failed(Throwable exc, ByteBuffer buffer) { 
                            exc.printStackTrace(); 
                        } 
                    }); 
                } catch (IOException e) { 
                    e.printStackTrace(); 
                } 
            } 
            @Override 
            public void failed(Throwable exc, Object attachment) { 
                exc.printStackTrace(); 
            } 
        }); 
        Thread.sleep(Integer.MAX_VALUE); 
    } 
}

客戶端

package com.niuh.aio; 
import java.net.InetSocketAddress; 
import java.nio.ByteBuffer; 
import java.nio.channels.AsynchronousSocketChannel; 
public class AIOClient { 
    public static void main(String... args) throws Exception { 
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9000)).get(); 
        socketChannel.write(ByteBuffer.wrap("HelloServer".getBytes())); 
        ByteBuffer buffer = ByteBuffer.allocate(512); 
        Integer len = socketChannel.read(buffer).get();        if (len != -1) { 
            System.out.println("客戶端收到信息：" + new String(buffer.array(), 0, len)); 
        }    }}

BIO、NIO、AIO對比

責任編輯：姜華來源：今日頭條

BIO 、NIO 、AIO 總結