java架構之路-（netty專題）初步認識BIO、NIO、AIO

　　本次我們主要來說一下我們的IO阻塞模型，只是不多，但是一定要理解，對於後面理解netty很重要的

IO模型精講 

　　IO模型就是說用什麼樣的通道進行數據的發送和接收，Java共支持3種網絡編程IO模式：BIO，NIO，AIO。

BIO

　　BIO(Blocking IO) 同步阻塞模型，一個客戶端連接對應一個處理線程。也是我們熟悉的同步阻塞模型，先別管那個同步的概念，我們先來看一下什麼是阻塞，簡單來一段代碼。

　　服務端：

package com.xiaocai.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("等待連接。。");
            //阻塞方法
            Socket socket = serverSocket.accept();
            System.out.println("有客戶端連接了。。");
            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.xiaocai.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();
    }
}

　　這個就是一個簡單的BIO服務端代碼，就是要準備接受線程訪問的代碼段。這一個單線程版本什麼意思呢？

　　我們先開啓一個端口爲9000的socket服務，然後運行Socket socket = serverSocket.accept();意思就是等待線程的出現，我們來接收客戶端的請求，這個方法時阻塞的，也是只有在阻塞狀態纔可以接收到我們的請求。當有請求進來時，運行handler(socket);方法，中間是打印線程ID的方法不解釋，int read = socket.getInputStream().read(bytes);準備讀取我們的客戶端發送數據。read和write可能會混淆，我畫個圖來說一下。

　　我們也可以看到我們的客戶端也是先拿到socket連接（Socket socket = new Socket("127.0.0.1", 9000)），然後要往服務端寫入數據（socket.getOutputStream().write("HelloServer".getBytes());）以byte字節形式寫入。這時我們的服務端等待read我們的客戶端weite的數據，會進入阻塞狀態，如果我們的客戶端遲遲不寫數據，我們的客戶端一直是阻塞狀態，也就無法接收到新的請求，因爲阻塞了，沒法回到我們的Socket socket = serverSocket.accept();去等待客戶端請求，只要在serverSocket.accept阻塞時纔可以接收新的請求。於是我們採取了多線程的方式來解決這個問題，我們來看一下代碼。

package com.xiaocai.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("等待連接。。");
            //阻塞方法
            Socket socket = serverSocket.accept();
            System.out.println("有客戶端連接了。。");
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(socket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    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();
    }
}

　　我們這時每次有客戶端來新的請求時，我們就會開啓一個線程來處理這個請求，及時你的客戶端沒有及時的write數據，雖然我們的服務端read進行了阻塞，也只是阻塞了你自己的線程，不會造成其它請求無法接收到。

 　　這樣的處理方式貌似好了很多很多，其實不然，想一個實例，我們的看小妹直播時，一句歡迎榜一大哥，彈幕很多，加入一次性來了100彈幕還好，我們開啓100個線程來處理，如果一起來了十萬彈幕呢？難道你要開啓十萬個線程來處理這些彈幕嘛？很顯然BIO還是有弊端的，BIO還是有優點的（代碼少，不容易出錯）。

NIO

　　NIO(Non Blocking IO) 同步非阻塞，服務器實現模式爲一個線程可以處理多個請求(連接)，客戶端發送的連接請求都會註冊到多路複用器selector上，多路複用器輪詢到連接有IO請求就進行處理。 可能概念太抽象了，我來舉個例子吧，現在有兩個小區都有很多的房子出租，BIO小區和NIO小區，都有一個門衛，BIO小區，來了一個租客，門衛大爺就拿着鑰匙，帶這個租客去看房子了，後面來的租客都暫時無法看房子了，尷尬...想同時多人看房子，必須增加門衛大爺的數量，而我們的NIO小區就很聰明，還是一個門衛大媽，來了一個租客要看房子，門衛大媽，給了那個租客一把鑰匙，並且告訴他哪房間是空的，你自己進去看吧，及時這個租客看房子慢，耽誤了很多時間也不怕了，因爲門衛大媽一直在門衛室，即使又來了新的租客，門衛大媽也是如此，只給鑰匙和空房間地址就可以了。這個例子反正我記得很清楚，也覺得很貼切，這裏提到了一個鑰匙的概念，一會告訴你們是做什麼的，我們先看一下代碼。

　　服務端

package com.xiaocai.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();
        }
    }
}

　　客戶端

package com.xiaocai.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超級重要後面的netty就是基於這個寫的，一定要搞懂，首先我們創建了一個ServerSocketChannel和一個選擇器selector，設置爲非阻塞的（固定寫法，沒有爲什麼），將我們的 selector綁定到我們的ServerSocketChannel上，然後運行selector.select();進入阻塞狀態，別擔心，這個阻塞沒影響，爲我們提供了接收客戶端的請求，你沒有請求，我阻塞着，不會耽誤你們什麼的。

　　回到我們的客戶端，還是差不多的樣子，拿到我們的NioClient開始連接我們的服務端，這個時候，我們的服務端接收到了我們的客戶端請求，阻塞狀態的selector.select()繼續運行，並且給予了一個SelectionKey（Iterator<SelectionKey> it = selector.selectedKeys().iterator()）也就是我們剛纔的小例子中提到的鑰匙，key=鑰匙，還算是靠譜吧~！開始運行我們的handle方法，有個if else，這個是說，你是第一次請求要建立通道，還是要寫數據，還是要讀取數據，記住啊，讀寫都是相對的，自己多琢磨幾次就可以轉過圈來了，就是我上面畫圖說的read和write。拿我們的建立通道來說，通過我們的鑰匙key你就可以得到ServerSocketChannel，然後進行設置下次可能會發生的讀寫事件，然後看我們的讀事件，我們看到了int len = sc.read(buffer)這個讀在我們的BIO中是阻塞的，而我們的NIO這個方法不是阻塞的，這也就體現出來了我們的BIO同步阻塞和NIO同步非阻塞，阻塞和非阻塞的區別也就說完了。畫個圖，我們來看一下我們的NIO模型。

　　NIO 有三大核心組件： Channel(通道)， Buffer(緩衝區)，Selector(選擇器)

 　　這裏我們的Buffer沒有去說，到netty會說的， Channel(通道)， Buffer(緩衝區)都是雙向的，現在回過頭來想想我舉的小例子，selector門衛大媽，SelectionKey鑰匙。對於NIO有了一些理解了吧，NIO看着很棒的，但是你有想過寫上述代碼的痛苦嗎？

AIO

　　AIO(NIO 2.0) 異步非阻塞， 由操作系統完成後回調通知服務端程序啓動線程去處理， 一般適用於連接數較多且連接時間較長的應用。其實AIO就是對於NIO的二次封裝，要不怎麼叫做NIO2.0呢，我們來簡單看一下代碼。

　　服務端：

package com.xiaocai.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(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.xiaocai.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));
        }
    }
}

　　阻塞非阻塞都明白了，這裏來解釋一下同步，我們看到我們的AIO在serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {}直接開啓了線程，也就是說accept直接以後，我不再需要考慮阻塞情況，可以繼續運行下面的代碼了，也就是我們說到的異步執行，內部還是我們的NIO，不要覺得AIO多麼的6B，內部就是封裝了我們的NIO，性能和NIO其實差不多的，可能有些時候還不如NIO（未實測）。

　　遺漏一個知識點，NIO的多路複用器是如何工作的，在我們的JDK1.5以前的，多路複用器是數組和鏈表的方式來遍歷的，到了我們的JDK1.5採用hash來回調的。

 總結：

　　我們這次主要說了BIO、NIO、AIO三個網絡編程IO模式，最重要的就是我們的NIO，一張圖來總結一下三個IO的差別吧。

 

 

最進弄了一個公衆號，小菜技術，歡迎大家的加入