一、簡介

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

(相關資料圖)

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

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

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

阻塞和非阻塞的區(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)中會調用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é)流轉化成字符流，讀取客戶端輸入的內容                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));                //讀取一行數(shù)據(jù)                String str = bufferedReader.readLine();                //打印客戶端發(fā)送的信息                System.out.println("服務端收到客戶端發(fā)送的信息：" + str);                //向客戶端返回信息，將字符轉化成字節(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);                        //將字符流轉化成字節(jié)流，并輸出                        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()),true);                        String str="Hello，我是" + j + "個，客戶端!";                        printWriter.println(str);                        //從輸入流中讀取服務端返回的信息，將字節(jié)流轉化成字符流                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));                        //讀取內容                        String result = bufferedReader.readLine();                        //打印服務端返回的信息                        System.out.println("客戶端發(fā)送請求內容：" + str + " -> 收到服務端返回的內容：" + 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ā)送請求內容：Hello，我是8個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是9個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是7個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是5個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是4個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是3個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是6個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是2個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是1個，客戶端! -> 收到服務端返回的內容：hello，我是服務端，已收到消息客戶端發(fā)送請求內容：Hello，我是0個，客戶端! -> 收到服務端返回的內容：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é)流轉化成字符流，讀取客戶端輸入的內容                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));                        //讀取一行數(shù)據(jù)                        String str = bufferedReader.readLine();                        //打印客戶端發(fā)送的信息                        System.out.println("線程名稱" + threadName + "，服務端收到客戶端發(fā)送的信息：" + str);                        //向客戶端返回信息，將字符轉化成字節(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é)流轉化成字符流，讀取客戶端輸入的內容                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));                        //讀取一行數(shù)據(jù)                        String str = bufferedReader.readLine();                        //打印客戶端發(fā)送的信息                        System.out.println("線程名稱" + threadName + "，服務端收到客戶端發(fā)送的信息：" + str);                        //向客戶端返回信息，將字符轉化成字節(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可以比作為一個車站的車輛運行調度系統(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 操作時，比如調用write()往 Socket 中的SendQ隊列寫數(shù)據(jù)時，當一次寫的數(shù)據(jù)超過SendQ長度時，操作系統(tǒng)會按照SendQ的長度進行分割的，這個過程中需要將用戶空間數(shù)據(jù)和內核地址空間進行切換，而這個切換不是程序員可以控制的，由底層操作系統(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 selectedKeys = selector.selectedKeys();            Iterator 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ā)送的信息，內容：" + 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ā)送內容        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ā)送的信息，內容：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，維護成本較高！

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

五、AIO

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

異步 IO 是基于事件回調機制實現(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(){            @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(){                            @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 {                    //當有新客戶端接入的時候，直接調用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("客戶端收到服務器返回的內容：" + result);//輸出返回結果        } catch (Exception e) {            e.printStackTrace();        }    }}

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

服務端控制臺結果如下：

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

客戶端控制臺結果如下：

客戶端收到服務器返回的內容：server send

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

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

六、小結

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

內容難免有所遺漏，歡迎留言指出！

七、參考

1、JDK1.7&JDK1.8 源碼

2、IBM - 許令波 -深入分析 Java I/O 的工作機制

3、Github - JavaGuide - IO總結

4、博客園 - 五月的倉頡 - IO和File

關鍵詞：