這兩天了解了一下關于NIO方面的知識，網上關于這一塊的介紹只是介紹了一下基本用法，沒有系統的解釋NIO與阻塞、非阻塞、同步、異步之間的聯系，導致自己困擾了好久。本篇文章就個人關于NIO的理解進行闡述。

一、NIO的概念

Java NIO(New IO)是一個可以替代標準Java IO API的IO API(從Java1.4開始)，Java NIO提供了與標準IO不同的IO工作方式。

所以Java NIO是一種新式的IO標準，與之間的普通IO的工作方式不同。標準的IO基于字節流和字符流進行操作的，而NIO是基于通道(Channel)和緩沖區(Buffer)進行操作，數據總是從通道讀取到緩沖區中，或者從緩沖區寫入通道也類似。

由上面的定義就說明NIO是一種新型的IO，但NIO不僅僅就是等于Non-blocking IO（非阻塞IO），NIO中有實現非阻塞IO的具體類，但不代表NIO就是Non-blocking IO（非阻塞IO）。

Java NIO 由以下幾個核心部分組成：

Buffer
Channel
Selector

傳統的IO操作面向數據流，意味著每次從流中讀一個或多個字節，直至完成，數據沒有被緩存在任何地方。NIO操作面向緩沖區，數據從Channel讀取到Buffer緩沖區，隨后在Buffer中處理數據。

二、Buffer的使用

利用Buffer讀寫數據，通常遵循四個步驟：

1.把數據寫入buffer；
2.調用flip；
3.從Buffer中讀取數據；
4.調用buffer.clear()

當寫入數據到buffer中時，buffer會記錄已經寫入的數據大小。當需要讀數據時，通過flip()方法把buffer從寫模式調整為讀模式；在讀模式下，可以讀取所有已經寫入的數據。

當讀取完數據后，需要清空buffer，以滿足后續寫入操作。清空buffer有兩種方式：調用clear()，一旦讀完Buffer中的數據，需要讓Buffer準備好再次被寫入，clear會恢復狀態值，但不會擦除數據。

Buffer的容量，位置，上限（Buffer Capacity, Position and Limit）

buffer緩沖區實質上就是一塊內存，用于寫入數據，也供后續再次讀取數據。這塊內存被NIO Buffer管理，并提供一系列的方法用于更簡單的操作這塊內存。

一個Buffer有三個屬性是必須掌握的，分別是：
capacity容量
position位置
limit限制

position和limit的具體含義取決于當前buffer的模式。capacity在兩種模式下都表示容量。
下面有張示例圖，描訴了不同模式下position和limit的含義：

buffers-modes.png

容量（Capacity）

作為一塊內存，buffer有一個固定的大小，叫做capacity容量。也就是最多只能寫入容量值得字節，整形等數據。一旦buffer寫滿了就需要清空已讀數據以便下次繼續寫入新的數據。

位置（Position）

當寫入數據到Buffer的時候需要中一個確定的位置開始，默認初始化時這個位置position為0，一旦寫入了數據比如一個字節，整形數據，那么position的值就會指向數據之后的一個單元，position最大可以到capacity-1.
當從Buffer讀取數據時，也需要從一個確定的位置開始。buffer從寫入模式變為讀取模式時，position會歸零，每次讀取后，position向后移動。

上限（Limit）
在寫模式，limit的含義是我們所能寫入的最大數據量。它等同于buffer的容量。
一旦切換到讀模式，limit則代表我們所能讀取的最大數據量，他的值等同于寫模式下position的位置。
數據讀取的上限時buffer中已有的數據，也就是limit的位置（原position所指的位置）。

分配一個Buffer（Allocating a Buffer）

為了獲取一個Buffer對象，你必須先分配。每個Buffer實現類都有一個allocate()方法用于分配內存。下面看一個實例,開辟一個48字節大小的buffer：

ByteBuffer buf = ByteBuffer.allocate(48);

開辟一個1024個字符的CharBuffer：

CharBuffer buf = CharBuffer.allocate(1024);

Buffer的實現類

三、Channel的使用

Java NIO Channel通道和流非常相似，主要有以下幾點區別：

通道可以讀也可以寫，流一般來說是單向的（只能讀或者寫）。
通道可以異步讀寫。
通道總是基于緩沖區Buffer來讀寫。
正如上面提到的，我們可以從通道中讀取數據，寫入到buffer；也可以中buffer內讀數據，寫入到通道中。下面有個示意圖：

Channel的實現類有：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel
還有一些異步IO類，后面有介紹。

FileChannel用于文件的數據讀寫。 DatagramChannel用于UDP的數據讀寫。 SocketChannel用于TCP的數據讀寫。 ServerSocketChannel允許我們監聽TCP鏈接請求，每個請求會創建會一個SocketChannel。

Channel使用實例

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
    FileChannel inChannel = aFile.getChannel();

    ByteBuffer buf = ByteBuffer.allocate(48);

    int bytesRead = inChannel.read(buf);
    while (bytesRead != -1) {

      System.out.println("Read " + bytesRead);
      buf.flip();

      while(buf.hasRemaining()){
          System.out.print((char) buf.get());
      }

      buf.clear();
      bytesRead = inChannel.read(buf);
    }
    aFile.close();

上面介紹了NIO中的兩個關鍵部分Buffer/Channel，對于Selector的介紹，先放一放，先介紹阻塞/非阻塞/同步/非同步的關系。

四、阻塞/非阻塞/同步/非同步的關系

為什么要介紹這四者的關系，就是因為Selector是對于多個非阻塞IO流的調度器，通過Selector來實現讀寫操作。所以有必要理解一下什么是阻塞/非阻塞？

以下內容轉載自：IO - 同步，異步，阻塞，非阻塞 （亡羊補牢篇）

本文討論的背景是UNIX環境下的network IO。本文最重要的參考文獻是Richard Stevens的“UNIX? Network Programming Volume 1, Third Edition: The Sockets Networking ”，6.2節“I/O Models ”，Stevens在這節中詳細說明了各種IO的特點和區別。

Stevens在文章中一共比較了五種IO Model：
blocking IO
nonblocking IO
IO multiplexing
signal driven IO
asynchronous IO。

由于signal driven IO在實際中并不常用，所以我這只提及剩下的四種IO Model。再說一下IO發生時涉及的對象和步驟。對于一個network IO (這里我們以read舉例)，它會涉及到兩個系統對象，一個是調用這個IO的process (or thread)，另一個就是系統內核(kernel)。

當一個read操作發生時，它會經歷兩個階段：
**1 等待數據準備 (Waiting for the data to be ready) **
2將數據從內核拷貝到進程中 (Copying the data from the kernel to the process)

記住這兩點很重要，因為這些IO Model的區別就是在兩個階段上各有不同的情況。

blocking IO

在UNIX中，默認情況下所有的socket都是blocking，一個典型的讀操作流程大概是這樣：

當用戶進程調用了recvfrom這個系統調用，kernel就開始了IO的第一個階段：準備數據。對于network io來說，很多時候數據在一開始還沒有到達（比如，還沒有收到一個完整的UDP包），這個時候kernel就要等待足夠的數據到來。而在用戶進程這邊，整個進程會被阻塞。當kernel一直等到數據準備好了，它就會將數據從kernel中拷貝到用戶內存，然后kernel返回結果，用戶進程才解除block的狀態，重新運行起來。所以，blocking IO的特點就是在IO執行的兩個階段都被block了。

non-blocking IO

UNIX下，可以通過設置socket使其變為non-blocking。當對一個non-blocking socket執行讀操作時，流程是這個樣子：

IO multiplexing

IO multiplexing這個詞可能有點陌生，但是如果我說select，epoll，大概就都能明白了。有些地方也稱這種IO方式為event driven IO。我們都知道，select/epoll的好處就在于單個process就可以同時處理多個網絡連接的IO。它的基本原理就是select/epoll這個function會不斷的輪詢所負責的所有socket，當某個socket有數據到達了，就通知用戶進程。它的流程如圖：

當用戶進程調用了select，那么整個進程會被block，而同時，kernel會“監視”所有select負責的socket，當任何一個socket中的數據準備好了，select就會返回。這個時候用戶進程再調用read操作，將數據從kernel拷貝到用戶進程。

這個圖和blocking IO的圖其實并沒有太大的不同，事實上，還更差一些。因為這里需要使用兩個system call (select 和 recvfrom)，而blocking IO只調用了一個system call (recvfrom)。但是，用select的優勢在于它可以同時處理多個connection。（多說一句。所以，如果處理的連接數不是很高的話，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延遲還更大。select/epoll的優勢并不是對于單個連接能處理得更快，而是在于能處理更多的連接。）

在IO multiplexing Model中，實際中，對于每一個socket，一般都設置成為non-blocking，但是，如上圖所示，整個用戶的process其實是一直被block的。只不過process是被select這個函數block，而不是被socket IO給block。

Asynchronous I/O

UNIX下的asynchronous IO其實用得很少。先看一下它的流程：

到目前為止，已經將四個IO Model都介紹完了。現在回過頭來回答最初的那幾個問題：

blocking和non-blocking的區別在哪，synchronous IO和asynchronous IO的區別在哪？

先回答最簡單的這個：blocking vs non-blocking。前面的介紹中其實已經很明確的說明了這兩者的區別。調用blocking IO會一直block住對應的進程直到操作完成，而non-blocking IO在kernel還準備數據的情況下會立刻返回。

在說明synchronous IO和asynchronous IO的區別之前，需要先給出兩者的定義。Stevens給出的定義（其實是POSIX的定義）是這樣子的：
A synchronous I/O operation causes the requesting process to be blocked until that I/O operationcompletes; An asynchronous I/O operation does not cause the requesting process to be blocked;

兩者的區別就在于synchronous IO做”IO operation”的時候會將process阻塞。

按照這個定義，之前所述的blocking IO，non-blocking IO，IO multiplexing都屬于synchronous IO。

有人可能會說，non-blocking IO并沒有被block啊。這里有個非常“狡猾”的地方，定義中所指的”IO operation”是指真實的IO操作，就是例子中的recvfrom這個system call。non-blocking IO在執行recvfrom這個system call的時候，如果kernel的數據沒有準備好，這時候不會block進程。但是，當kernel中數據準備好的時候，recvfrom會將數據從kernel拷貝到用戶內存中，這個時候進程是被block了，在這段時間內，進程是被block的。而asynchronous IO則不一樣，當進程發起IO 操作之后，就直接返回再也不理睬了，直到kernel發送一個信號，告訴進程說IO完成。在這整個過程中，進程完全沒有被block。

各個IO Model的比較如圖所示：

經過上面的介紹，會發現non-blocking IO和asynchronous IO的區別還是很明顯的。在non-blocking IO中，雖然進程大部分時間都不會被block，但是它仍然要求進程去主動的check，并且當數據準備完成以后，也需要進程主動的再次調用recvfrom來將數據拷貝到用戶內存。而asynchronous IO則完全不同。它就像是用戶進程將整個IO操作交給了他人（kernel）完成，然后他人做完后發信號通知。在此期間，用戶進程不需要去檢查IO操作的狀態，也不需要主動的去拷貝數據。

五、NIO中的blocking IO/nonblocking IO/IO multiplexing/asynchronous IO

上面講完了IO中的幾種模式，雖然是基于UNIX環境下，具體操作系統的知識個人認識很淺，下面就說下自己的個人理解，不對的地方歡迎指正。

首先，標準的IO顯然屬于blocking IO。

其次，NIO中的實現了SelectableChannel類的對象，可以通過如下方法設置是否支持非阻塞模式：

SelectableChannel configureBlocking(boolean block)：調整此通道的阻塞模式。

如果為 true，則此通道將被置于阻塞模式；如果為 false，則此通道將被置于非阻塞模式
設置為false的NIO類將是nonblocking IO。

再其次，通過Selector監聽實現多個NIO對象的讀寫操作，顯然屬于IO multiplexing。關于Selector，其負責調度多個非阻塞式IO，當有其感興趣的讀寫操作到來時，再執行相應的操作。Selector執行select()方法來進行輪詢查找是否到來了讀寫操作，這個過程是阻塞的，具體詳細使用下面介紹。

最后，在Java 7中增加了asynchronous IO，具體結構和實現類框架如下：

六、Selector使用

以下內容參考：Java NIO Selector選擇器

Selector是Java NIO中的一個組件，用于檢查一個或多個NIO Channel的狀態是否處于可讀、可寫。如此可以實現單線程管理多個channels,也就是可以管理多個網絡鏈接。

通過上面的了解我們知道Selector是一種IO multiplexing的情況。

下面這幅圖描述了單線程處理三個channel的情況：

創建Selector(Creating a Selector)。創建一個Selector可以通過Selector.open()方法：

Selector selector = Selector.open();

注冊Channel到Selector上：

channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

Channel必須是非阻塞的。上面對IO multiplexing的圖解中可以看出。所以FileChannel不適用Selector，因為FileChannel不能切換為非阻塞模式。Socket channel可以正常使用。

注意register的第二個參數，這個參數是一個“關注集合”，代表我們關注的channel狀態，有四種基礎類型可供監聽：

Connect
Accept
Read
Write

一個channel觸發了一個事件也可視作該事件處于就緒狀態。

因此當channel與server連接成功后，那么就是“Connetct”狀態。server channel接收請求連接時處于“Accept”狀態。channel有數據可讀時處于“Read”狀態。channel可以進行數據寫入時處于“Writer”狀態。當注冊到Selector的所有Channel注冊完后，調用Selector的select()方法，將會不斷輪詢檢查是否有以上設置的狀態產生，如果產生便會加入到SelectionKey集合中，進行后續操作。

上述的四種就緒狀態用SelectionKey中的常量表示如下：

SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE

如果對多個事件感興趣可利用位的或運算結合多個常量，比如：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

從Selector中選擇channel(Selecting Channels via a Selector)

一旦我們向Selector注冊了一個或多個channel后，就可以調用select來獲取channel。select方法會返回所有處于就緒狀態的channel。

select方法具體如下：

int select()
int select(long timeout)
int selectNow()

select()方法在返回channel之前處于阻塞狀態。 select(long timeout)和select做的事一樣，不過他的阻塞有一個超時限制。

selectNow()不會阻塞，根據當前狀態立刻返回合適的channel。

select()方法的返回值是一個int整形，代表有多少channel處于就緒了。也就是自上一次select后有多少channel進入就緒。

舉例來說，假設第一次調用select時正好有一個channel就緒，那么返回值是1，并且對這個channel做任何處理，接著再次調用select，此時恰好又有一個新的channel就緒，那么返回值還是1，現在我們一共有兩個channel處于就緒，但是在每次調用select時只有一個channel是就緒的。

selectedKeys()

在調用select并返回了有channel就緒之后，可以通過選中的key集合來獲取channel，這個操作通過調用selectedKeys()方法：

Set<SelectionKey> selectedKeys = selector.selectedKeys();    

遍歷這些SelectionKey可以通過如下方法：

Set<SelectionKey> selectedKeys = selector.selectedKeys();

Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

while(keyIterator.hasNext()) {

    SelectionKey key = keyIterator.next();

    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.

    } else if (key.isConnectable()) {
        // a connection was established with a remote server.

    } else if (key.isReadable()) {
        // a channel is ready for reading

    } else if (key.isWritable()) {
        // a channel is ready for writing
    }

    keyIterator.remove();
}

上述循環會迭代key集合，針對每個key我們單獨判斷他是處于何種就緒狀態。

注意keyIterater.remove()方法的調用，Selector本身并不會移除SelectionKey對象，這個操作需要我們收到執行。當下次channel處于就緒是，Selector任然會把這些key再次加入進來。

SelectionKey.channel返回的channel實例需要強轉為我們實際使用的具體的channel類型，例如ServerSocketChannel或SocketChannel.

wakeUp()

由于調用select而被阻塞的線程，可以通過調用Selector.wakeup()來喚醒即便此時已然沒有channel處于就緒狀態。具體操作是，在另外一個線程調用wakeup，被阻塞與select方法的線程就會立刻返回。

close()

當操作Selector完畢后，需要調用close方法。close的調用會關閉Selector并使相關的SelectionKey都無效。channel本身不管被關閉。

完整的Selector案例

這有一個完整的案例，首先打開一個Selector,然后注冊channel，最后調用select()獲取感興趣的操作：

Selector selector = Selector.open();

channel.configureBlocking(false);

SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

while(true) {

  int readyChannels = selector.select();

  if(readyChannels == 0) continue;

  Set<SelectionKey> selectedKeys = selector.selectedKeys();

  Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

  while(keyIterator.hasNext()) {

    SelectionKey key = keyIterator.next();

    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.

    } else if (key.isConnectable()) {
        // a connection was established with a remote server.

    } else if (key.isReadable()) {
        // a channel is ready for reading

    } else if (key.isWritable()) {
        // a channel is ready for writing
    }

    keyIterator.remove();
  }
}

當然NIO的知識點不止如此，還有很多。
以上是我對NIO的一些理解，網上資料也比較亂，不知道自己理解的對不對，涉及底層的東西自己沒辦法判別正誤，有不對的地方歡迎指正。