這兩天瞭解了一下關於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的實現類

 

其中MappedByteBuffer比較特殊。Java類庫中的NIO包相對於IO 包來說有一個新功能是記憶體對映檔案，日常程式設計中並不是經常用到，但是在處理大檔案時是比較理想的提高效率的手段。其中MappedByteBuffer實現的就是記憶體對映檔案，可以實現大檔案的高效讀寫。 可以參考這兩篇文章理解： [Java][IO]JAVA NIO之淺談記憶體對映檔案原理與DirectMemory，深入淺出MappedByteBuffer。

 

三、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執行讀操作時，流程是這個樣子：

從圖中可以看出，當用戶程序發出read操作時，如果kernel中的資料還沒有準備好，那麼它並不會block使用者程序，而是立刻返回一個error。從使用者程序角度講 ，它發起一個read操作後，並不需要等待，而是馬上就得到了一個結果。使用者程序判斷結果是一個error時，它就知道資料還沒有準備好，於是它可以再次傳送read操作。一旦kernel中的資料準備好了，並且又再次收到了使用者程序的system call，那麼它馬上就將資料拷貝到了使用者記憶體，然後返回。所以，使用者程序其實是需要不斷的主動詢問kernel資料好了沒有。

 

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其實用得很少。先看一下它的流程：

使用者程序發起read操作之後，立刻就可以開始去做其它的事。而另一方面，從kernel的角度，當它受到一個asynchronous read之後，首先它會立刻返回，所以不會對使用者程序產生任何block。然後，kernel會等待資料準備完成，然後將資料拷貝到使用者記憶體，當這一切都完成之後，kernel會給使用者程序傳送一個signal，告訴它read操作完成了。

 

到目前為止，已經將四個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，具體結構和實現類框架如下：

 

篇幅有限，具體使用可以看這篇文章：Java 學習之路 之 基於TCP協議的網路程式設計（八十二）。

 

六、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的一些理解，網上資料也比較亂，不知道自己理解的對不對，涉及底層的東西自己沒辦法判別正誤，有不對的地方歡迎指正。

作者：Ruheng
連結：https://www.jianshu.com/p/a9b2fec31fd1
來源：簡書
簡書著作權歸作者所有，任何形式的轉載都請聯絡作者獲得授權並註明出處。