BIO、NIO、AIO 模型工作方式

一、簡介

在計算機中，IO 傳輸數(shù)據(jù)有三種工作方式，分別是： BIO、NIO、AIO 。

在講解 BIO、NIO、AIO 之前，我們先來回顧一下這幾個概念： 同步與異步，阻塞與非阻塞 。

同步與異步的區(qū)別

• 同步就是發(fā)起一個請求后，接受者未處理完請求之前，不返回結果。
• 異步就是發(fā)起一個請求后，立刻得到接受者的回應表示已接收到請求，但是接受者并沒有處理完，接受者通常依靠事件回調(diào)等機制來通知請求者其處理結果。

阻塞和非阻塞的區(qū)別

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

而我們要講的 BIO、NIO、AIO 就是同步與異步、阻塞與非阻塞的組合。

• BIO：同步阻塞 IO；
• NIO：同步非阻塞 IO；
• AIO：異步非阻塞 IO;

不同的工作方式，帶來的傳輸效率是不一樣的，下面我們以網(wǎng)絡 IO 為例，一起看看不同的工作方式下，彼此之間有何不同 。

二、BIO

BIO 俗稱同步阻塞 IO，是一種非常傳統(tǒng)的 IO 模型，也是最常用的網(wǎng)絡數(shù)據(jù)傳輸處理方式，優(yōu)點就是編程簡單，但是缺點也很明顯，I/O 傳輸性能一般比較差，CPU 大部分處于空閑狀態(tài)。

采用 BIO 通信模型的服務端，通常由一個獨立的 Acceptor 線程負責監(jiān)聽所有客戶端的連接，當服務端接受到多個客戶端的請求時，所有的客戶端只能排隊等待服務端一個一個的處理。

BIO 通信模型圖如下！

一般在服務端通過while(true)循環(huán)中會調(diào)用accept()方法監(jiān)聽客戶端的連接，一旦接收到一個連接請求，就可以建立通信套接字進行讀寫操作，此時不能再接收其他客戶端連接請求，只能等待同當前連接的客戶端的操作執(zhí)行完成。

服務端操作，樣例程序如下 ：

public class BioServerTest {

    public static void main(String[] args) throws IOException {
        //初始化服務端socket并且綁定 8080 端口
        ServerSocket serverSocket = new ServerSocket(8080);
        //循環(huán)監(jiān)聽客戶端請求
        while (true){
            try {
                //監(jiān)聽客戶端請求
                Socket socket = serverSocket.accept();

                //將字節(jié)流轉(zhuǎn)化成字符流，讀取客戶端輸入的內(nèi)容
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                //讀取一行數(shù)據(jù)
                String str = bufferedReader.readLine();
                //打印客戶端發(fā)送的信息
                System.out.println("服務端收到客戶端發(fā)送的信息：" + str);

                //向客戶端返回信息，將字符轉(zhuǎn)化成字節(jié)流，并輸出
                PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                printWriter.println("hello，我是服務端，已收到消息");

                // 關閉流
                bufferedReader.close();
                printWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客戶端操作，樣例程序如下 ：

public class BioClientTest {

    public static void main(String[] args) {
        //創(chuàng)建10個線程，模擬10個客戶端，同時向服務端發(fā)送請求
        for (int i = 0; i < 10; i++) {
            final int j = i;//定義變量
            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        //通過IP和端口與服務端建立連接
                        Socket socket =new Socket("127.0.0.1",8080);
                        //將字符流轉(zhuǎn)化成字節(jié)流，并輸出
                        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                        String str="Hello，我是" + j + "個，客戶端!";
                        printWriter.println(str);

                        //從輸入流中讀取服務端返回的信息，將字節(jié)流轉(zhuǎn)化成字符流
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        //讀取內(nèi)容
                        String result = bufferedReader.readLine();
                        //打印服務端返回的信息
                        System.out.println("客戶端發(fā)送請求內(nèi)容：" + str + " - > 收到服務端返回的內(nèi)容：" + result);

                        // 關閉流
                        bufferedReader.close();
                        printWriter.close();
                        // 關閉socket
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

最后，依次啟動服務端、客戶端，看看控制臺輸出情況如何。

服務端控制臺結果如下：

服務端收到客戶端發(fā)送的信息：Hello，我是8個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是9個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是7個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是5個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是4個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是3個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是6個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是2個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是1個，客戶端!
服務端收到客戶端發(fā)送的信息：Hello，我是0個，客戶端!

客戶端控制臺結果如下：

客戶端發(fā)送請求內(nèi)容：Hello，我是8個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是9個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是7個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是5個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是4個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是3個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是6個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是2個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是1個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息
客戶端發(fā)送請求內(nèi)容：Hello，我是0個，客戶端! - > 收到服務端返回的內(nèi)容：hello，我是服務端，已收到消息

隨著客戶端的請求次數(shù)越來越多，可能需要排隊的時間會越來越長，因此是否可以在服務端，采用多線程編程進行處理呢？

答案是，可以的！

下面我們對服務端的代碼進行改造，服務端多線程操作，樣例程序如下：

public class BioServerTest {

    public static void main(String[] args) throws IOException {
        //初始化服務端socket并且綁定 8080 端口
        ServerSocket serverSocket = new ServerSocket(8080);
        //循環(huán)監(jiān)聽客戶端請求
        while (true){
            //監(jiān)聽客戶端請求
            Socket socket = serverSocket.accept();
            new Thread(new Runnable() {

                @Override
                public void run() {
                    try {
                        String threadName = Thread.currentThread().toString();
                        //將字節(jié)流轉(zhuǎn)化成字符流，讀取客戶端輸入的內(nèi)容
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        //讀取一行數(shù)據(jù)
                        String str = bufferedReader.readLine();
                        //打印客戶端發(fā)送的信息
                        System.out.println("線程名稱" + threadName + "，服務端收到客戶端發(fā)送的信息：" + str);

                        //向客戶端返回信息，將字符轉(zhuǎn)化成字節(jié)流，并輸出
                        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                        printWriter.println("hello，我是服務端，已收到消息");

                        // 關閉流
                        bufferedReader.close();
                        printWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

依次啟動服務端、客戶端，服務端控制臺輸出結果如下：

線程名稱Thread[Thread-8,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是4個，客戶端!
線程名稱Thread[Thread-4,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是8個，客戶端!
線程名稱Thread[Thread-0,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是1個，客戶端!
線程名稱Thread[Thread-7,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是5個，客戶端!
線程名稱Thread[Thread-5,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是2個，客戶端!
線程名稱Thread[Thread-9,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是3個，客戶端!
線程名稱Thread[Thread-1,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是0個，客戶端!
線程名稱Thread[Thread-3,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是7個，客戶端!
線程名稱Thread[Thread-2,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是9個，客戶端!
線程名稱Thread[Thread-6,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是6個，客戶端!

當服務端接收到客戶端的請求時，會給每個客戶端創(chuàng)建一個新的線程進行鏈路處理，處理完成之后，通過輸出流返回應答給客戶端，最后線程會銷毀。

但是這樣的編程模型也有很大的弊端，如果出現(xiàn) 100、1000、甚至 10000 個客戶端同時請求服務端，采用這種編程模型，服務端也會創(chuàng)建與之相同的線程數(shù)量， 線程數(shù)急劇膨脹可能會導致線程堆棧溢出、創(chuàng)建新線程失敗等問題，最終可能導致服務端宕機或者僵死，不能對外提供服務 。

三、偽異步 BIO

為了解決上面提到的同步阻塞 I/O 面臨的一個鏈路需要一個線程處理的問題，后來有人對它的編程模型進行了優(yōu)化。

在服務端通過使用 Java 中ThreadPoolExecutor線程池機制來處理多個客戶端的請求接入，防止由于海量并發(fā)接入導致資源耗盡，讓線程的創(chuàng)建和回收成本相對較低，保證了系統(tǒng)有限的資源得以控制，實現(xiàn)了 N （客戶端請求數(shù)量）大于 M （服務端處理客戶端請求的線程數(shù)量）的偽異步 I/O 模型。

偽異步 IO 模型圖，如下圖：

采用線程池和任務隊列可以實現(xiàn)一種叫做偽異步的 I/O 通信框架，當有新的客戶端接入時，將客戶端的 Socket 封裝成一個 Task 投遞到線程池中進行處理。

服務端采用線程池處理客戶端請求，樣例程序如下：

public class BioServerTest {

    public static void main(String[] args) throws IOException {
        //在線程池中創(chuàng)建5個固定大小線程，來處理客戶端的請求
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        //初始化服務端socket并且綁定 8080 端口
        ServerSocket serverSocket = new ServerSocket(8080);
        //循環(huán)監(jiān)聽客戶端請求
        while (true){
            //監(jiān)聽客戶端請求
            Socket socket = serverSocket.accept();
            //使用線程池執(zhí)行任務
            executorService.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        String threadName = Thread.currentThread().toString();
                        //將字節(jié)流轉(zhuǎn)化成字符流，讀取客戶端輸入的內(nèi)容
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        //讀取一行數(shù)據(jù)
                        String str = bufferedReader.readLine();
                        //打印客戶端發(fā)送的信息
                        System.out.println("線程名稱" + threadName + "，服務端收到客戶端發(fā)送的信息：" + str);

                        //向客戶端返回信息，將字符轉(zhuǎn)化成字節(jié)流，并輸出
                        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);
                        printWriter.println("hello，我是服務端，已收到消息");

                        // 關閉流
                        bufferedReader.close();
                        printWriter.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

依次啟動服務端、客戶端，服務端控制臺輸出結果如下：

線程名稱Thread[pool-1-thread-4,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是6個，客戶端!
線程名稱Thread[pool-1-thread-2,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是8個，客戶端!
線程名稱Thread[pool-1-thread-3,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是9個，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是5個，客戶端!
線程名稱Thread[pool-1-thread-1,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是7個，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是2個，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是0個，客戶端!
線程名稱Thread[pool-1-thread-1,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是1個，客戶端!
線程名稱Thread[pool-1-thread-5,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是3個，客戶端!
線程名稱Thread[pool-1-thread-1,5,main]，服務端收到客戶端發(fā)送的信息：Hello，我是4個，客戶端!

本例中測試的客戶端數(shù)量是 10，服務端使用 java 線程池來處理任務，線程數(shù)量為 5 個，服務端不用為每個客戶端都創(chuàng)建一個線程，由于線程池可以設置消息隊列的大小和最大線程數(shù)，因此它的資源占用是可控的，無論多少個客戶端并發(fā)訪問，都不會導致資源的耗盡和宕機。

在活動連接數(shù)不是特別高的情況下，這種模型還是不錯的，可以讓每一個連接專注于自己的 I/O 并且編程模型簡單，也不用過多考慮系統(tǒng)的過載、限流等問題。

但是，它的底層仍然是同步阻塞的 BIO 模型，當面對十萬甚至百萬級請求接入的時候，傳統(tǒng)的 BIO 模型無能為力，因此我們需要一種更高效的 I/O 處理模型來應對更高的并發(fā)量。

四、NIO

NIO，英文全稱： Non-blocking-IO ，一種同步非阻塞的 I/O 模型。

在 Java 1.4 中引入，對應的代碼在java.nio包下。

與傳統(tǒng)的 IO 不同，NIO 新增了 Channel、Selector、Buffer 等抽象概念， 支持面向緩沖、基于通道的 I/O 數(shù)據(jù)傳輸方法 。

NIO 模型圖，如下圖：

與此同時，NIO 還提供了與傳統(tǒng) BIO 模型中的 Socket 和 ServerSocket 相對應的 SocketChannel 和 ServerSocketChannel 兩種不同的套接字通道實現(xiàn)。

NIO 這兩種通道都支持阻塞和非阻塞兩種模式。阻塞模式使用就像傳統(tǒng)中的 BIO 一樣，比較簡單，但是性能和可靠性都不好； 非阻塞模式正好與之相反 。

對于低負載、低并發(fā)的應用程序，可以使用同步阻塞 I/O 來提升開發(fā)效率和更好的維護性；對于高負載、高并發(fā)的（ 網(wǎng)絡 ）應用，使用 NIO 的非阻塞模式來開發(fā)可以顯著的提升數(shù)據(jù)傳輸效率。

在介紹樣例之前，我們先看一下 NIO 涉及到的核心關聯(lián)類圖，如下：

上圖中有三個關鍵類： Channel 、Selector 和 Buffer ，它們是 NIO 中的核心概念。

• Channel：可以理解為通道；
• Selector：可以理解為選擇器；
• Buffer：可以理解為數(shù)據(jù)緩沖區(qū)；

從名詞上看感覺很抽象，我們還是用之前介紹的城市交通工具來繼續(xù)形容 NIO 的工作方式，這里的 Channel 要比 Socket 更加具體，它可以比作為某種具體的交通工具，如汽車或是高鐵、飛機等，而 Selector 可以比作為一個車站的車輛運行調(diào)度系統(tǒng)，它將負責監(jiān)控每輛車的當前運行狀態(tài)，是已經(jīng)出站還是在路上等等，也就是說它可以輪詢每個 Channel 的狀態(tài)。

還有一個 Buffer 類，你可以將它看作為 IO 中 Stream ，但是它比 IO 中的 Stream 更加具體化，我們可以將它比作為車上的座位，Channel 如果是汽車的話，那么 Buffer 就是汽車上的座位，Channel 如果是高鐵上，那么 Buffer 就是高鐵上的座位，它始終是一個具體的概念，這一點與 Stream 不同。

Socket 中的 Stream 只能代表是一個座位，至于是什么座位由你自己去想象，也就是說你在上車之前并不知道這個車上是否還有座位，也不知道上的是什么車，因為你并不能選擇，這些信息都已經(jīng)被封裝在了運輸工具（ Socket ）里面了。

NIO 引入了 Channel、Buffer 和 Selector 就是想把 IO 傳輸過程中涉及到的 信息具體化 ，讓程序員有機會去控制它們。

當我們進行傳統(tǒng)的網(wǎng)絡 IO 操作時，比如調(diào)用write()往 Socket 中的SendQ隊列寫數(shù)據(jù)時，當一次寫的數(shù)據(jù)超過SendQ長度時，操作系統(tǒng)會按照SendQ 的長度進行分割的，這個過程中需要將用戶空間數(shù)據(jù)和內(nèi)核地址空間進行切換，而這個切換不是程序員可以控制的，由底層操作系統(tǒng)來幫我們處理。

而在Buffer中，我們可以控制Buffer的capacity（容量），并且是否擴容以及如何擴容都可以控制。

理解了這些概念后我們看一下，實際上它們是如何工作的呢？

我們一起來看看代碼實例！

服務端操作，樣例程序如下 ：

/**
 * NIO 服務端
 */
public class NioServerTest {

    public static void main(String[] args) throws IOException {
        // 打開服務器套接字通道
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 服務器配置為非阻塞
        ssc.configureBlocking(false);
        // 進行服務的綁定，監(jiān)聽8080端口
        ssc.socket().bind(new InetSocketAddress(8080));

        // 構建一個Selector選擇器,并且將channel注冊上去
        Selector selector = Selector.open();
        // 將serverSocketChannel注冊到selector,并對accept事件感興趣(serverSocketChannel只能支持accept操作)
        ssc.register(selector, SelectionKey.OP_ACCEPT);

        while (true){
            // 查詢指定事件已經(jīng)就緒的通道數(shù)量，select方法有阻塞效果,直到有事件通知才會有返回，如果為0就跳過
            int readyChannels = selector.select();
            if(readyChannels == 0) {
                continue;
            };
            //通過選擇器取得所有key集合
            Set< SelectionKey > selectedKeys = selector.selectedKeys();
            Iterator< SelectionKey > iterator = selectedKeys.iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                //判斷狀態(tài)是否有效
                if (!key.isValid()) {
                    continue;
                }
                if (key.isAcceptable()) {
                    // 處理通道中的連接事件
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel sc = server.accept();
                    sc.configureBlocking(false);
                    System.out.println("接收到新的客戶端連接，地址：" + sc.getRemoteAddress());

                    // 將通道注冊到選擇器并處理通道中可讀事件
                    sc.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    // 處理通道中的可讀事件
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    while (channel.isOpen() && channel.read(byteBuffer) != -1) {
                        // 長連接情況下,需要手動判斷數(shù)據(jù)有沒有讀取結束 (此處做一個簡單的判斷: 超過0字節(jié)就認為請求結束了)
                        if (byteBuffer.position() > 0) {
                            break;
                        };
                    }
                    byteBuffer.flip();

                    //獲取緩沖中的數(shù)據(jù)
                    String result = new String(byteBuffer.array(), 0, byteBuffer.limit());
                    System.out.println("收到客戶端發(fā)送的信息，內(nèi)容：" + result);

                    // 將通道注冊到選擇器并處理通道中可寫事件
                    channel.register(selector, SelectionKey.OP_WRITE);
                } else if (key.isWritable()) {
                    // 處理通道中的可寫事件
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    byteBuffer.put("server send".getBytes());
                    byteBuffer.flip();
                    channel.write(byteBuffer);

                    // 將通道注冊到選擇器并處理通道中可讀事件
                    channel.register(selector, SelectionKey.OP_READ);
                    //寫完之后關閉通道
                    channel.close();
                }
                //當前事件已經(jīng)處理完畢，可以丟棄
                iterator.remove();
            }
        }
    }
}

客戶端操作，樣例程序如下 ：

/**
 * NIO 客戶端
 */
public class NioClientTest {

    public static void main(String[] args) throws IOException {
        // 打開socket通道
        SocketChannel sc = SocketChannel.open();
        //設置為非阻塞
        sc.configureBlocking(false);
        //連接服務器地址和端口
        sc.connect(new InetSocketAddress("127.0.0.1", 8080));
        while (!sc.finishConnect()) {
            // 沒連接上,則一直等待
            System.out.println("客戶端正在連接中，請耐心等待");
        }

        // 發(fā)送內(nèi)容
        ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
        writeBuffer.put("Hello，我是客戶端".getBytes());
        writeBuffer.flip();
        sc.write(writeBuffer);

        // 讀取響應
        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
        while (sc.isOpen() && sc.read(readBuffer) != -1) {
            // 長連接情況下,需要手動判斷數(shù)據(jù)有沒有讀取結束 (此處做一個簡單的判斷: 超過0字節(jié)就認為請求結束了)
            if (readBuffer.position() > 0) {
                break;
            };
        }
        readBuffer.flip();

        String result = new String(readBuffer.array(), 0, readBuffer.limit());
        System.out.println("客戶端收到服務端：" + sc.socket().getRemoteSocketAddress() + "，返回的信息：" + result);

        // 關閉通道
        sc.close();
    }
}

最后，依次啟動服務端、客戶端，看看控制臺輸出情況如何。

服務端控制臺結果如下：

接收到新的客戶端連接，地址：/127.0.0.1:57644
收到客戶端發(fā)送的信息，內(nèi)容：Hello，我是客戶端

客戶端控制臺結果如下：

客戶端收到服務端：/127.0.0.1:8080，返回的信息：server send

從編程上可以看到，NIO 的操作比傳統(tǒng)的 IO 操作要復雜的多 ！

Selector 被稱為選擇器 ，當然你也可以翻譯為多路復用器 。它是Java NIO 核心組件中的一個，用于檢查一個或多個 Channel （通道）的狀態(tài)是否處于 連接就緒 、 接受就緒 、 可讀就緒 、 可寫就緒 。

如此可以實現(xiàn)單線程管理多個 channels 的目的，也就是可以管理多個網(wǎng)絡連接。

使用 Selector 的好處在于 ：相比傳統(tǒng)方式使用多個線程來管理 IO，Selector 使用了更少的線程就可以處理通道了，并且實現(xiàn)網(wǎng)絡高效傳輸！

雖然 Java 中的 nio 傳輸比較快，為什么大家都不愿意用 JDK 原生 NIO 進行開發(fā)呢？

從上面的代碼中大家都可以看出來，除了編程復雜之外，還有幾個讓人詬病的問題：

• JDK 的 NIO 底層由 epoll 實現(xiàn)，該實現(xiàn)飽受詬病的空輪詢 bug 會導致 cpu 飆升 100%！
• 項目龐大之后，自行實現(xiàn)的 NIO 很容易出現(xiàn)各類 bug，維護成本較高！

但是，Netty 框架的出現(xiàn)，很大程度上改善了 JDK 原生 NIO 所存在的一些讓人難以忍受的問題 ，關于 Netty 框架應用，會在后期的文章里進行介紹。

五、AIO

最后就是 AIO 了，全稱 Asynchronous I/O，可以理解為異步 IO，也被稱為 NIO 2，在 Java 7 中引入，它是異步非阻塞的 IO 模型。

異步 IO 是基于事件回調(diào)機制實現(xiàn)的，也就是應用操作之后會直接返回，不會堵塞在那里，當后臺處理完成，操作系統(tǒng)會通知相應的線程進行后續(xù)的操作。

具體的實例如下！

服務端操作，樣例程序如下 ：

/**
 * aio 服務端
 */
public class AioServer {

    public AsynchronousServerSocketChannel serverChannel;

    /**
     * 監(jiān)聽客戶端請求
     * @throws Exception
     */
    public void listen() throws Exception {
        //打開一個服務端通道
        serverChannel = AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));//監(jiān)聽8080端口
        //服務監(jiān)聽
        serverChannel.accept(this, new CompletionHandler< AsynchronousSocketChannel,AioServer >(){

            @Override
            public void completed(AsynchronousSocketChannel client, AioServer attachment) {
                try {
                    if (client.isOpen()) {
                        System.out.println("接收到新的客戶端連接，地址：" + client.getRemoteAddress());
                        final ByteBuffer buffer = ByteBuffer.allocate(1024);
                        //讀取客戶端發(fā)送的信息
                        client.read(buffer, client, new CompletionHandler< Integer, AsynchronousSocketChannel >(){

                            @Override
                            public void completed(Integer result, AsynchronousSocketChannel attachment) {
                                try {
                                    //讀取請求，處理客戶端發(fā)送的數(shù)據(jù)
                                    buffer.flip();
                                    String content = new String(buffer.array(), 0, buffer.limit());
                                    System.out.println("服務端收到客戶端發(fā)送的信息：" + content);

                                    //向客戶端發(fā)送數(shù)據(jù)
                                    ByteBuffer writeBuffer = ByteBuffer.allocate(1024);
                                    writeBuffer.put("server send".getBytes());
                                    writeBuffer.flip();
                                    attachment.write(writeBuffer).get();
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }

                            @Override
                            public void failed(Throwable exc, AsynchronousSocketChannel attachment) {
                                try {
                                    exc.printStackTrace();
                                    attachment.close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        });
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //當有新客戶端接入的時候，直接調(diào)用accept方法，遞歸執(zhí)行下去，保證多個客戶端都可以阻塞
                    attachment.serverChannel.accept(attachment, this);
                }
            }

            @Override
            public void failed(Throwable exc, AioServer attachment) {
                exc.printStackTrace();
            }
        });
    }

    public static void main(String[] args) throws Exception {
        //啟動服務器，并監(jiān)聽客戶端
        new AioServer().listen();
        //因為是異步IO執(zhí)行，讓主線程睡眠但不關閉
        Thread.sleep(Integer.MAX_VALUE);
    }
}

客戶端操作，樣例程序如下 ：

/**
 * aio 客戶端
 */
public class AioClient {

    public static void main(String[] args) throws IOException, InterruptedException {
        //打開一個客戶端通道
        AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
        //與服務器建立連接
        channel.connect(new InetSocketAddress("127.0.0.1", 8080));

        //睡眠1s，等待與服務器建立連接
        Thread.sleep(1000);
        try {
            //向服務器發(fā)送數(shù)據(jù)
            channel.write(ByteBuffer.wrap("Hello，我是客戶端".getBytes())).get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            //從服務器讀取數(shù)據(jù)
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            channel.read(byteBuffer).get();//將通道中的數(shù)據(jù)寫入緩沖buffer
            byteBuffer.flip();
            String result = new String(byteBuffer.array(), 0, byteBuffer.limit());
            System.out.println("客戶端收到服務器返回的內(nèi)容：" + result);//輸出返回結果
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

同樣的，依次啟動服務端程序，再啟動客戶端程序，看看運行結果！

服務端控制臺結果如下：

接收到新的客戶端連接，地址：/127.0.0.1:56606
服務端收到客戶端發(fā)送的信息：Hello，我是客戶端

客戶端控制臺結果如下：

客戶端收到服務器返回的內(nèi)容：server send

這種組合方式用起來十分復雜，只有在一些非常復雜的分布式情況下使用，像集群之間的消息同步機制一般用這種 I/O 組合方式。如 Cassandra 的 Gossip 通信機制就是采用異步非阻塞的方式，可以實現(xiàn)非常高的網(wǎng)絡傳輸性能。

Netty 之前也嘗試使用過 AIO，不過又放棄了！

六、小結

本文主要圍繞 BIO、NIO、AIO 等模型，結合一些樣例代碼，做了一次簡單的內(nèi)容知識總結，希望對大家有所幫助。