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

• Java NIO: Channels and Buffers（通道和緩衝區）：標準的IO基於位元組流和字元流進行操作的，而NIO是基於通道（Channel）和緩衝區（Buffer）進行操作，資料總是從通道讀取到緩衝區中，或者從緩衝區寫入到通道中。
• Java NIO: Non-blocking IO（非阻塞IO）：Java NIO可以讓你非阻塞的使用IO，例如：當執行緒從通道讀取資料到緩衝區時，執行緒還是可以進行其他事情。當資料被寫入到緩衝區時，執行緒可以繼續處理它。從緩衝區寫入通道也類似。
• Java NIO: Selectors（選擇器）：Java NIO引入了選擇器的概念，選擇器用於監聽多個通道的事件（比如：連線開啟，資料到達）。因此，單個的執行緒可以監聽多個數據通道。

各章節直達連結：

一、Java NIO 概述

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

• Channels
• Buffers
• Selectors

雖然Java NIO 中除此之外還有很多類和元件，但在我看來，Channel，Buffer 和 Selector 構成了核心的API。其它元件，如Pipe和FileLock，只不過是與三個核心元件共同使用的工具類。因此，在概述中我將集中在這三個元件上。其它元件會在單獨的章節中講到。

Channel 和 Buffer

基本上，所有的 IO 在NIO 中都從一個Channel 開始。Channel 有點象流。 資料可以從Channel讀到Buffer中，也可以從Buffer 寫到Channel中。這裡有個圖示：



Channel和Buffer有好幾種類型。下面是JAVA NIO中的一些主要Channel的實現：

• FileChannel
• DatagramChannel
• SocketChannel
• ServerSocketChannel

正如你所看到的，這些通道涵蓋了UDP 和 TCP 網路IO，以及檔案IO。
與這些類一起的有一些有趣的介面，但為簡單起見，我儘量在概述中不提到它們。本教程其它章節與它們相關的地方我會進行解釋。

以下是Java NIO裡關鍵的Buffer實現：

• ByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

這些Buffer覆蓋了你能通過IO傳送的基本資料型別：byte, short, int, long, float, double 和 char。
Java NIO 還有個 MappedByteBuffer，用於表示記憶體對映檔案， 我也不打算在概述中說明。

Selector

Selector允許單執行緒處理多個 Channel。如果你的應用打開了多個連線（通道），但每個連線的流量都很低，使用Selector就會很方便。例如，在一個聊天伺服器中。
這是在一個單執行緒中使用一個Selector處理3個Channel的圖示：



要使用Selector，得向Selector註冊Channel，然後呼叫它的select()方法。這個方法會一直阻塞到某個註冊的通道有事件就緒。一旦這個方法返回，執行緒就可以處理這些事件，事件的例子有如新連線進來，資料接收等。

二、Channal

Java NIO的通道類似流，但又有些不同：

• 既可以從通道中讀取資料，又可以寫資料到通道。但流的讀寫通常是單向的。
• 通道可以非同步地讀寫。
• 通道中的資料總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。

正如上面所說，從通道讀取資料到緩衝區，從緩衝區寫入資料到通道。如下圖所示：



Channel的實現

這些是Java NIO中最重要的通道的實現：

• FileChannel
• DatagramChannel
• SocketChannel
• ServerSocketChannel

FileChannel 從檔案中讀寫資料。
DatagramChannel 能通過UDP讀寫網路中的資料。
SocketChannel 能通過TCP讀寫網路中的資料。
ServerSocketChannel可以監聽新進來的TCP連線，像Web伺服器那樣。對每一個新進來的連線都會建立一個SocketChannel。

基本的 Channel 示例

下面是一個使用FileChannel讀取資料到Buffer中的示例：

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

注意 buf.flip() 的呼叫，首先讀取資料到Buffer，然後反轉Buffer,接著再從Buffer中讀取資料。下一節會深入講解Buffer的更多細節。

三、Buffer

Java NIO中的Buffer用於和NIO通道進行互動。如你所知，資料是從通道讀入緩衝區，從緩衝區寫入到通道中的。
緩衝區本質上是一塊可以寫入資料，然後可以從中讀取資料的記憶體。這塊記憶體被包裝成NIO Buffer物件，並提供了一組方法，用來方便的訪問該塊記憶體。

Buffer的基本用法

使用Buffer讀寫資料一般遵循以下四個步驟：

1. 寫入資料到Buffer
2. 呼叫flip()方法
3. 從Buffer中讀取資料
4. 呼叫clear()方法或者compact()方法

當向buffer寫入資料時，buffer會記錄下寫了多少資料。一旦要讀取資料，需要通過flip()方法將Buffer從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有資料。
一旦讀完了所有的資料，就需要清空緩衝區，讓它可以再次被寫入。有兩種方式能清空緩衝區：呼叫clear()或compact()方法。

• clear()方法會清空整個緩衝區。
• compact()方法只會清除已經讀過的資料。任何未讀的資料都被移到緩衝區的起始處，新寫入的資料將放到緩衝區未讀資料的後面。

下面是一個使用Buffer的例子：

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();
//create buffer with capacity of 48 bytes
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf); //read into buffer.
while (bytesRead != -1) {
  buf.flip(); //make buffer ready for read
  while(buf.hasRemaining()){
      System.out.print((char) buf.get()); // read 1 byte at a time
  }
  buf.clear(); //make buffer ready for writing
  bytesRead = inChannel.read(buf);
}
aFile.close();

Buffer的capacity,position和limit

緩衝區本質上是一塊可以寫入資料，然後可以從中讀取資料的記憶體。這塊記憶體被包裝成NIO Buffer物件，並提供了一組方法，用來方便的訪問該塊記憶體。
為了理解Buffer的工作原理，需要熟悉它的三個屬性：

• capacity
• position
• limit

position和limit的含義取決於Buffer處在讀模式還是寫模式。不管Buffer處在什麼模式，capacity的含義總是一樣的。

這裡有一個關於capacity，position和limit在讀寫模式中的說明，詳細的解釋在插圖後面。



• capacity：作為一個記憶體塊，Buffer有一個固定的大小值，也叫“capacity”.你只能往裡寫capacity個byte、long，char等型別。一旦Buffer滿了，需要將其清空（通過讀資料或者清除資料）才能繼續寫資料往裡寫資料。
• position：當你寫資料到Buffer中時，position表示當前的位置。初始的position值為0.當一個byte、long等資料寫到Buffer後， position會向前移動到下一個可插入資料的Buffer單元。position最大可為capacity – 1。 當讀取資料時，也是從某個特定位置讀。當將Buffer從寫模式切換到讀模式，position會被重置為0. 當從Buffer的position處讀取資料時，position向前移動到下一個可讀的位置。
• limit：在寫模式下，Buffer的limit表示你最多能往Buffer裡寫多少資料。 寫模式下，limit等於Buffer的capacity。當切換Buffer到讀模式時， limit表示你最多能讀到多少資料。因此，當切換Buffer到讀模式時，limit會被設定成寫模式下的position值。換句話說，你能讀到之前寫入的所有資料（limit被設定成已寫資料的數量，這個值在寫模式下就是position）。

Buffer的型別

Java NIO 有以下Buffer型別

• ByteBuffer
• MappedByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

如你所見，這些Buffer型別代表了不同的資料型別。換句話說，就是可以通過char，short，int，long，float 或 double型別來操作緩衝區中的位元組。

MappedByteBuffer 有些特別，在涉及它的專門章節中再講。

Buffer的分配

要想獲得一個Buffer物件首先要進行分配。 每一個Buffer類都有一個allocate()方法。下面是一個分配48位元組capacity的ByteBuffer的例子。

ByteBuffer buf = ByteBuffer.allocate(48);

這是分配一個可儲存1024個字元的CharBuffer：

CharBuffer buf = CharBuffer.allocate(1024);

向Buffer中寫資料

寫資料到Buffer有兩種方式：

• 從Channel寫到Buffer。
• 通過Buffer的put()方法寫到Buffer裡。

從Channel寫到Buffer的例子

int bytesRead = inChannel.read(buf); //read into buffer.

通過put()方法寫Buffer的例子：

buf.put(127);

put()方法有很多版本，允許你以不同的方式把資料寫入到Buffer中。例如， 寫到一個指定的位置，或者把一個位元組陣列寫入到Buffer。 更多Buffer實現的細節參考JavaDoc。

flip()方法

flip()方法將Buffer從寫模式切換到讀模式。呼叫flip()方法會將position設回0，並將limit設定成之前position的值。

換句話說，position現在用於標記讀的位置，limit表示之前寫進了多少個byte、char等 —— 現在能讀取多少個byte、char等。

從Buffer中讀取資料

從Buffer中讀取資料有兩種方式：

• 從Buffer讀取資料到Channel。
• 使用get()方法從Buffer中讀取資料。

從Buffer讀取資料到Channel的例子：

//read from buffer into channel.
int bytesWritten = inChannel.write(buf);

使用get()方法從Buffer中讀取資料的例子

byte aByte = buf.get();

get()方法有很多版本，允許你以不同的方式從Buffer中讀取資料。例如，從指定position讀取，或者從Buffer中讀取資料到位元組陣列。更多Buffer實現的細節參考JavaDoc。

rewind()方法

Buffer.rewind()將position設回0，所以你可以重讀Buffer中的所有資料。limit保持不變，仍然表示能從Buffer中讀取多少個元素（byte、char等）。

clear()與compact()方法

一旦讀完Buffer中的資料，需要讓Buffer準備好再次被寫入。可以通過clear()或compact()方法來完成。

• 如果呼叫的是clear()方法，position將被設回0，limit被設定成 capacity的值。換句話說，Buffer 被清空了。Buffer中的資料並未清除，只是這些標記告訴我們可以從哪裡開始往Buffer裡寫資料。如果Buffer中有一些未讀的資料，呼叫clear()方法，資料將“被遺忘”，意味著不再有任何標記會告訴你哪些資料被讀過，哪些還沒有。

• 如果Buffer中仍有未讀的資料，且後續還需要這些資料，但是此時想要先先寫些資料，那麼使用compact()方法。compact()方法將所有未讀的資料拷貝到Buffer起始處。然後將position設到最後一個未讀元素正後面。limit屬性依然像clear()方法一樣，設定成capacity。現在Buffer準備好寫資料了，但是不會覆蓋未讀的資料。

mark()與reset()方法

通過呼叫Buffer.mark()方法，可以標記Buffer中的一個特定position。之後可以通過呼叫Buffer.reset()方法恢復到這個position。例如：

buffer.mark();
//call buffer.get() a couple of times, e.g. during parsing.
buffer.reset(); //set position back to mark.

equals()與compareTo()方法

可以使用equals()和compareTo()方法兩個Buffer。

equals()

當滿足下列條件時，表示兩個Buffer相等：

1. 有相同的型別（byte、char、int等）。
2. Buffer中剩餘的byte、char等的個數相等。
3. Buffer中所有剩餘的byte、char等都相同。

如你所見，equals只是比較Buffer的一部分，不是每一個在它裡面的元素都比較。實際上，它只比較Buffer中的剩餘元素。

compareTo()方法

compareTo()方法比較兩個Buffer的剩餘元素(byte、char等)， 如果滿足下列條件，則認為一個Buffer“小於”另一個Buffer：

1. 第一個不相等的元素小於另一個Buffer中對應的元素 。
2. 所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少。

（譯註：剩餘元素是從 position到limit之間的元素）

四、Scatter/Gather

Java NIO開始支援scatter/gather，scatter/gather用於描述從Channel（譯者注：Channel在中文經常翻譯為通道）中讀取或者寫入到Channel的操作。

• 分散（scatter）：從Channel中讀取是指在讀操作時將讀取的資料寫入多個buffer中。因此，Channel將從Channel中讀取的資料“分散（scatter）”到多個Buffer中。
• 聚集（gather）：寫入Channel是指在寫操作時將多個buffer的資料寫入同一個Channel，因此，Channel 將多個Buffer中的資料“聚集（gather）”後傳送到Channel。

scatter / gather經常用於需要將傳輸的資料分開處理的場合，例如傳輸一個由訊息頭和訊息體組成的訊息，你可能會將訊息體和訊息頭分散到不同的buffer中，這樣你可以方便的處理訊息頭和訊息體。

Scattering Reads

Scattering Reads是指資料從一個channel讀取到多個buffer中。如下圖描述：



程式碼示例如下：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
ByteBuffer[] bufferArray = { header, body };
channel.read(bufferArray);

注意buffer首先被插入到陣列，然後再將陣列作為channel.read() 的輸入引數。read()方法按照buffer在陣列中的順序將從channel中讀取的資料寫入到buffer，當一個buffer被寫滿後，channel緊接著向另一個buffer中寫。

Scattering Reads在移動下一個buffer前，必須填滿當前的buffer，這也意味著它不適用於動態訊息(譯者注：訊息大小不固定)。換句話說，如果存在訊息頭和訊息體，訊息頭必須完成填充（例如 128byte），Scattering Reads才能正常工作。

Gathering Writes

Gathering Writes是指資料從多個buffer寫入到同一個channel。如下圖描述：



程式碼示例如下：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
//write data into buffers
ByteBuffer[] bufferArray = { header, body };
channel.write(bufferArray);

buffers陣列是write()方法的入參，write()方法會按照buffer在陣列中的順序，將資料寫入到channel，注意只有position和limit之間的資料才會被寫入。因此，如果一個buffer的容量為128byte，但是僅僅包含58byte的資料，那麼這58byte的資料將被寫入到channel中。因此與Scattering Reads相反，Gathering Writes能較好的處理動態訊息。

五、通道之間的資料傳輸

在Java NIO中，如果兩個通道中有一個是FileChannel，那你可以直接將資料從一個channel（譯者注：channel中文常譯作通道）傳輸到另外一個channel。

transferFrom()

FileChannel的transferFrom()方法可以將資料從源通道傳輸到FileChannel中（譯者注：這個方法在JDK文件中的解釋為將位元組從給定的可讀取位元組通道傳輸到此通道的檔案中）。下面是一個簡單的例子：

javaRandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannel fromChannel = fromFile.getChannel();
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChannel toChannel = toFile.getChannel();
long position = 0;
long count = fromChannel.size();
toChannel.transferFrom(fromChannel, position, count);

方法的輸入引數position表示從position處開始向目標檔案寫入資料，count表示最多傳輸的位元組數。如果源通道的剩餘空間小於 count 個位元組，則所傳輸的位元組數要小於請求的位元組數。
此外要注意，在SoketChannel的實現中，SocketChannel只會傳輸此刻準備好的資料（可能不足count位元組）。因此，SocketChannel可能不會將請求的所有資料(count個位元組)全部傳輸到FileChannel中。

transferTo()

transferTo()方法將資料從FileChannel傳輸到其他的channel中。下面是一個簡單的例子：

RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannel fromChannel = fromFile.getChannel();
RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChannel toChannel = toFile.getChannel();
long position = 0;
long count = fromChannel.size();
fromChannel.transferTo(position, count, toChannel);

是不是發現這個例子和前面那個例子特別相似？除了呼叫方法的FileChannel物件不一樣外，其他的都一樣。
上面所說的關於SocketChannel的問題在transferTo()方法中同樣存在。SocketChannel會一直傳輸資料直到目標buffer被填滿。

六、Selector

Selector（選擇器）是Java NIO中能夠檢測一到多個NIO通道，並能夠知曉通道是否為諸如讀寫事件做好準備的元件。這樣，一個單獨的執行緒可以管理多個channel，從而管理多個網路連線。

為什麼使用Selector?

僅用單個執行緒來處理多個Channels的好處是，只需要更少的執行緒來處理通道。事實上，可以只用一個執行緒處理所有的通道。對於作業系統來說，執行緒之間上下文切換的開銷很大，而且每個執行緒都要佔用系統的一些資源（如記憶體）。因此，使用的執行緒越少越好。

但是，需要記住，現代的作業系統和CPU在多工方面表現的越來越好，所以多執行緒的開銷隨著時間的推移，變得越來越小了。實際上，如果一個CPU有多個核心，不使用多工可能是在浪費CPU能力。不管怎麼說，關於那種設計的討論應該放在另一篇不同的文章中。在這裡，只要知道使用Selector能夠處理多個通道就足夠了。

下面是單執行緒使用一個Selector處理3個channel的示例圖：



Selector的建立

通過呼叫Selector.open()方法建立一個Selector，如下：

Selector selector = Selector.open();

向Selector註冊通道

為了將Channel和Selector配合使用，必須將channel註冊到selector上。通過

SelectableChannel.register()方法來實現，如下：

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

與Selector一起使用時，Channel必須處於非阻塞模式下。這意味著不能將FileChannel與Selector一起使用，因為FileChannel不能切換到非阻塞模式。而套接字通道都可以。

注意register()方法的第二個引數。這是一個“interest集合”，意思是在通過Selector監聽Channel時對什麼事件感興趣。可以監聽四種不同型別的事件：

1. Connect
2. Accept
3. Read
4. Write

通道觸發了一個事件意思是該事件已經就緒。所以，某個channel成功連線到另一個伺服器稱為“連線就緒”。一個server socket channel準備好接收新進入的連線稱為“接收就緒”。一個有資料可讀的通道可以說是“讀就緒”。等待寫資料的通道可以說是“寫就緒”。

這四種事件用SelectionKey的四個常量來表示：

1. SelectionKey.OP_CONNECT
2. SelectionKey.OP_ACCEPT
3. SelectionKey.OP_READ
4. SelectionKey.OP_WRITE

如果你對不止一種事件感興趣，那麼可以用“位或”操作符將常量連線起來，如下：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

在下面還會繼續提到interest集合。

SelectionKey

在上一小節中，當向Selector註冊Channel時，register()方法會返回一個SelectionKey物件。這個物件包含了一些你感興趣的屬性：

• interest集合
• ready集合
• Channel
• Selector
• 附加的物件（可選）

下面我會描述這些屬性。

interest集合

就像向Selector註冊通道一節中所描述的，interest集合是你所選擇的感興趣的事件集合。可以通過SelectionKey讀寫interest集合，像這樣：

int interestSet = selectionKey.interestOps();
boolean isInterestedInAccept = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;

可以看到，用“位與”操作interest 集合和給定的SelectionKey常量，可以確定某個確定的事件是否在interest 集合中。

ready集合

ready 集合是通道已經準備就緒的操作的集合。在一次選擇(Selection)之後，你會首先訪問這個ready set。Selection將在下一小節進行解釋。可以這樣訪問ready集合：

int readySet = selectionKey.readyOps();

可以用像檢測interest集合那樣的方法，來檢測channel中什麼事件或操作已經就緒。但是，也可以使用以下四個方法，它們都會返回一個布林型別：

selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

Channel + Selector

從SelectionKey訪問Channel和Selector很簡單。如下：

Channel channel = selectionKey.channel();
Selector selector = selectionKey.selector();

附加的物件

可以將一個物件或者更多資訊附著到SelectionKey上，這樣就能方便的識別某個給定的通道。例如，可以附加 與通道一起使用的Buffer，或是包含聚集資料的某個物件。使用方法如下：

selectionKey.attach(theObject);
Object attachedObj = selectionKey.attachment();

還可以在用register()方法向Selector註冊Channel的時候附加物件。如：

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

通過Selector選擇通道

一旦向Selector註冊了一或多個通道，就可以呼叫幾個過載的select()方法。這些方法返回你所感興趣的事件（如連線、接受、讀或寫）已經準備就緒的那些通道。換句話說，如果你對“讀就緒”的通道感興趣，select()方法會返回讀事件已經就緒的那些通道。

下面是select()方法：

• int select()：阻塞到至少有一個通道在你註冊的事件上就緒了。
• int select(long timeout)：和select()一樣，除了最長會阻塞timeout毫秒(引數)。
• int selectNow()：不會阻塞，不管什麼通道就緒都立刻返回（譯者注：此方法執行非阻塞的選擇操作。如果自從前一次選擇操作後，沒有通道變成可選擇的，則此方法直接返回零）。

select()方法返回的int值表示有多少通道已經就緒。亦即，自上次呼叫select()方法後有多少通道變成就緒狀態。如果呼叫select()方法，因為有一個通道變成就緒狀態，返回了1，若再次呼叫select()方法，如果另一個通道就緒了，它會再次返回1。如果對第一個就緒的channel沒有做任何操作，現在就有兩個就緒的通道，但在每次select()方法呼叫之間，只有一個通道就緒了。

selectedKeys()

一旦呼叫了select()方法，並且返回值表明有一個或更多個通道就緒了，然後可以通過呼叫selector的selectedKeys()方法，訪問“已選擇鍵集（selected key set）”中的就緒通道。如下所示：

Set selectedKeys = selector.selectedKeys();

當像Selector註冊Channel時，Channel.register()方法會返回一個SelectionKey 物件。這個物件代表了註冊到該Selector的通道。可以通過SelectionKey的selectedKeySet()方法訪問這些物件。

可以遍歷這個已選擇的鍵集合來訪問就緒的通道。如下：

Set selectedKeys = selector.selectedKeys();
Iterator 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();
}

這個迴圈遍歷已選擇鍵集中的每個鍵，並檢測各個鍵所對應的通道的就緒事件。

注意每次迭代末尾的keyIterator.remove()呼叫。Selector不會自己從已選擇鍵集中移除SelectionKey例項。必須在處理完通道時自己移除。下次該通道變成就緒時，Selector會再次將其放入已選擇鍵集中。

SelectionKey.channel()方法返回的通道需要轉型成你要處理的型別，如ServerSocketChannel或SocketChannel等。

wakeUp()

某個執行緒呼叫select()方法後阻塞了，即使沒有通道已經就緒，也有辦法讓其從select()方法返回。只要讓其它執行緒在第一個執行緒呼叫select()方法的那個物件上呼叫Selector.wakeup()方法即可。阻塞在select()方法上的執行緒會立馬返回。

如果有其它執行緒呼叫了wakeup()方法，但當前沒有執行緒阻塞在select()方法上，下個呼叫select()方法的執行緒會立即“醒來（wake up）”。

close()

用完Selector後呼叫其close()方法會關閉該Selector，且使註冊到該Selector上的所有SelectionKey例項無效。通道本身並不會關閉。

完整的示例

這裡有一個完整的示例，開啟一個Selector，註冊一個通道註冊到這個Selector上(通道的初始化過程略去),然後持續監控這個Selector的四種事件（接受，連線，讀，寫）是否就緒。

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 selectedKeys = selector.selectedKeys();
  Iterator 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();
  }
}

七、FileChannel

Java NIO中的FileChannel是一個連線到檔案的通道。可以通過檔案通道讀寫檔案。

FileChannel無法設定為非阻塞模式，它總是執行在阻塞模式下。

開啟FileChannel

在使用FileChannel之前，必須先開啟它。但是，我們無法直接開啟一個FileChannel，需要通過使用一個InputStream、OutputStream或RandomAccessFile來獲取一個FileChannel例項。

下面是通過RandomAccessFile開啟FileChannel的示例：

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

從FileChannel讀取資料

呼叫多個read()方法之一從FileChannel中讀取資料。如：

ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);

首先，分配一個Buffer。從FileChannel中讀取的資料將被讀到Buffer中。

然後，呼叫FileChannel.read()方法。該方法將資料從FileChannel讀取到Buffer中。read()方法返回的int值表示了有多少位元組被讀到了Buffer中。如果返回-1，表示到了檔案末尾。

向FileChannel寫資料

使用FileChannel.write()方法向FileChannel寫資料，該方法的引數是一個Buffer。如：

String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
    channel.write(buf);
}

注意FileChannel.write()是在while迴圈中呼叫的。因為無法保證write()方法一次能向FileChannel寫入多少位元組，因此需要重複呼叫write()方法，直到Buffer中已經沒有尚未寫入通道的位元組。

關閉FileChannel

用完FileChannel後必須將其關閉。如：

channel.close();

FileChannel的position方法

有時可能需要在FileChannel的某個特定位置進行資料的讀/寫操作。可以通過呼叫position()方法獲取FileChannel的當前位置。

也可以通過呼叫position(long pos)方法設定FileChannel的當前位置。

這裡有兩個例子:

long pos = channel.position();
channel.position(pos +123);

• 如果將位置設定在檔案結束符之後，然後試圖從檔案通道中讀取資料，讀方法將返回-1 —— 檔案結束標誌。
• 如果將位置設定在檔案結束符之後，然後向通道中寫資料，檔案將撐大到當前位置並寫入資料。這可能導致“檔案空洞”，磁碟上物理檔案中寫入的資料間有空隙。

FileChannel的size方法

FileChannel例項的size()方法將返回該例項所關聯檔案的大小。如:

long fileSize = channel.size();

FileChannel的truncate方法

可以使用FileChannel.truncate()方法擷取一個檔案。擷取檔案時，檔案將中指定長度後面的部分將被刪除。如：

channel.truncate(1024);

這個例子擷取檔案的前1024個位元組。

FileChannel的force方法

FileChannel.force()方法將通道里尚未寫入磁碟的資料強制寫到磁碟上。出於效能方面的考慮，作業系統會將資料快取在記憶體中，所以無法保證寫入到FileChannel裡的資料一定會即時寫到磁碟上。要保證這一點，需要呼叫force()方法。

force()方法有一個boolean型別的引數，指明是否同時將檔案元資料（許可權資訊等）寫到磁碟上。

下面的例子同時將檔案資料和元資料強制寫到磁碟上：

channel.force(true);

八、SocketChannel

Java NIO中的SocketChannel是一個連線到TCP網路套接字的通道。可以通過以下2種方式建立SocketChannel：

1. 開啟一個SocketChannel並連線到網際網路上的某臺伺服器。
2. 一個新連線到達ServerSocketChannel時，會建立一個SocketChannel。

開啟 SocketChannel

下面是SocketChannel的開啟方式：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("http://jenkov.com", 80));

關閉 SocketChannel

當用完SocketChannel之後呼叫SocketChannel.close()關閉SocketChannel：

socketChannel.close();

從 SocketChannel 讀取資料

要從SocketChannel中讀取資料，呼叫一個read()的方法之一。以下是例子：

ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = socketChannel.read(buf);

首先，分配一個Buffer。從SocketChannel讀取到的資料將會放到這個Buffer中。

然後，呼叫SocketChannel.read()。該方法將資料從SocketChannel 讀到Buffer中。read()方法返回的int值表示讀了多少位元組進Buffer裡。如果返回的是-1，表示已經讀到了流的末尾（連線關閉了）。

寫入 SocketChannel

寫資料到SocketChannel用的是SocketChannel.write()方法，該方法以一個Buffer作為引數。示例如下：

String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
    channel.write(buf);
}

注意SocketChannel.write()方法的呼叫是在一個while迴圈中的。write()方法無法保證能寫多少位元組到SocketChannel。所以，我們重複呼叫write()直到Buffer沒有要寫的位元組為止。

非阻塞模式

可以設定 SocketChannel 為非阻塞模式（non-blocking mode）.設定之後，就可以在非同步模式下呼叫connect(),read()和write()了。

connect()

如果SocketChannel在非阻塞模式下，此時呼叫connect()，該方法可能在連線建立之前就返回了。為了確定連線是否建立，可以呼叫finishConnect()的方法。像這樣：

socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("http://jenkov.com", 80));
while(! socketChannel.finishConnect() ){
    //wait, or do something else...    
}

write()

非阻塞模式下，write()方法在尚未寫出任何內容時可能就返回了。所以需要在迴圈中呼叫write()。前面已經有例子了，這裡就不贅述了。

read()

非阻塞模式下,read()方法在尚未讀取到任何資料時可能就返回了。所以需要關注它的int返回值，它會告訴你讀取了多少位元組。

非阻塞模式與選擇器

非阻塞模式與選擇器搭配會工作的更好，通過將一或多個SocketChannel註冊到Selector，可以詢問選擇器哪個通道已經準備好了讀取，寫入等。Selector與SocketChannel的搭配使用會在後面詳講。

九、ServerSocketChannel

Java NIO中的 ServerSocketChannel 是一個可以監聽新進來的TCP連線的通道, 就像標準IO中的ServerSocket一樣。ServerSocketChannel類在java.nio.channels包中。

這裡有個例子：

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.socket().bind(new InetSocketAddress(9999));
while(true){
    SocketChannel socketChannel =
            serverSocketChannel.accept();
    //do something with socketChannel...
}

開啟 ServerSocketChannel

通過呼叫 ServerSocketChannel.open()方法來開啟ServerSocketChannel.如：

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

關閉 ServerSocketChannel

通過呼叫ServerSocketChannel.close()方法來關閉ServerSocketChannel. 如：

serverSocketChannel.close();

監聽新進來的連線

通過 ServerSocketChannel.accept()方法監聽新進來的連線。當 accept()方法返回的時候,它返回一個包含新進來的連線的 SocketChannel。因此, accept()方法會一直阻塞到有新連線到達。

通常不會僅僅只監聽一個連線,在while迴圈中呼叫 accept()方法. 如下面的例子：

while(true){
    SocketChannel socketChannel =
            serverSocketChannel.accept();
    //do something with socketChannel...
}

當然,也可以在while迴圈中使用除了true以外的其它退出準則。

非阻塞模式

ServerSocketChannel可以設定成非阻塞模式。在非阻塞模式下，accept()方法會立刻返回，如果還沒有新進來的連線,返回的將是null。 因此，需要檢查返回的SocketChannel是否是null.如：

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.socket().bind(new InetSocketAddress(9999));
serverSocketChannel.configureBlocking(false);
while(true){
    SocketChannel socketChannel =
            serverSocketChannel.accept();
    if(socketChannel != null){
        //do something with socketChannel...
    }
}

十、DatagramChannel

Java NIO中的DatagramChannel是一個能收發UDP包的通道。因為UDP是無連線的網路協議，所以不能像其它通道那樣讀取和寫入。它傳送和接收的是資料包。

開啟 DatagramChannel

下面是 DatagramChannel 的開啟方式：

DatagramChannel channel = DatagramChannel.open();
channel.socket().bind(new InetSocketAddress(9999));

這個例子開啟的 DatagramChannel可以在UDP埠9999上接收資料包。

接收資料

通過receive()方法從DatagramChannel接收資料，如：

ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();

channel.receive(buf);

receive()方法會將接收到的資料包內容複製到指定的Buffer. 如果Buffer容不下收到的資料，多出的資料將被丟棄。

傳送資料

通過send()方法從DatagramChannel傳送資料，如:

String newData = "New String to write to file..."
                    + System.currentTimeMillis();

ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
int bytesSent = channel.send(buf, new InetSocketAddress("jenkov.com", 80));

這個例子傳送一串字元到”jenkov.com”伺服器的UDP埠80。 因為服務端並沒有監控這個埠，所以什麼也不會發生。也不會通知你發出的資料包是否已收到，因為UDP在資料傳送方面沒有任何保證。

連線到特定的地址

可以將DatagramChannel“連線”到網路中的特定地址的。由於UDP是無連線的，連線到特定地址並不會像TCP通道那樣建立一個真正的連線。而是鎖住DatagramChannel ，讓其只能從特定地址收發資料。

這裡有個例子:

channel.connect(new InetSocketAddress("jenkov.com", 80));

當連線後，也可以使用read()和write()方法，就像在用傳統的通道一樣。只是在資料傳送方面沒有任何保證。這裡有幾個例子：

int bytesRead = channel.read(buf);

int bytesWritten = channel.write(but);

十一、Pipe

Java NIO 管道是2個執行緒之間的單向資料連線。Pipe有一個source通道和一個sink通道。資料會被寫到sink通道，從source通道讀取。

這裡是Pipe原理的圖示：



建立管道

通過Pipe.open()方法開啟管道。例如：

Pipe pipe = Pipe.open();

向管道寫資料

要向管道寫資料，需要訪問sink通道。像這樣：

Pipe.SinkChannel sinkChannel = pipe.sink();

通過呼叫SinkChannel的write()方法，將資料寫入SinkChannel,像這樣：

String newData = "New String to write to file..." + System.currentTimeMillis();
ByteBuffer buf = ByteBuffer.allocate(48);
buf.clear();
buf.put(newData.getBytes());
buf.flip();
while(buf.hasRemaining()) {
    sinkChannel.write(buf);
}

從管道讀取資料

從讀取管道的資料，需要訪問source通道，像這樣：

Pipe.SourceChannel sourceChannel = pipe.source();

呼叫source通道的read()方法來讀取資料，像這樣：

ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = sourceChannel.read(buf);

read()方法返回的int值會告訴我們多少位元組被讀進了緩衝區。

十二、NIO與IO

當學習了Java NIO和IO的API後，一個問題馬上湧入腦海：

我應該何時使用IO，何時使用NIO呢？在本文中，我會盡量清晰地解析Java NIO和IO的差異、它們的使用場景，以及它們如何影響您的程式碼設計。

Java NIO和IO的主要區別

下表總結了Java NIO和IO之間的主要差別，我會更詳細地描述表中每部分的差異。

IO	NIO
面向流	面向緩衝
阻塞IO	非阻塞IO
無	選擇器

面向流與面向緩衝

Java NIO和IO之間第一個最大的區別是，IO是面向流的，NIO是面向緩衝區的。

Java IO面向流意味著每次從流中讀一個或多個位元組，直至讀取所有位元組，它們沒有被快取在任何地方。此外，它不能前後移動流中的資料。如果需要前後移動從流中讀取的資料，需要先將它快取到一個緩衝區。

Java NIO的緩衝導向方法略有不同。資料讀取到一個它稍後處理的緩衝區，需要時可在緩衝區中前後移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩衝區中包含所有您需要處理的資料。而且，需確保當更多的資料讀入緩衝區時，不要覆蓋緩衝區裡尚未處理的資料。

阻塞與非阻塞IO

Java IO的各種流是阻塞的。這意味著，當一個執行緒呼叫read()或 write()時，該執行緒被阻塞，直到有一些資料被讀取，或資料完全寫入。該執行緒在此期間不能再幹任何事情了。

Java NIO的非阻塞模式，使一個執行緒從某通道傳送請求讀取資料，但是它僅能得到目前可用的資料，如果目前沒有資料可用時，就什麼都不會獲取。而不是保持執行緒阻塞，所以直至資料變的可以讀取之前，該執行緒可以繼續做其他的事情。

非阻塞寫也是如此。一個執行緒請求寫入一些資料到某通道，但不需要等待它完全寫入，這個執行緒同時可以去做別的事情。

執行緒通常將非阻塞IO的空閒時間用於在其它通道上執行IO操作，所以一個單獨的執行緒現在可以管理多個輸入和輸出通道（channel）。

選擇器（Selectors）

Java NIO的選擇器允許一個單獨的執行緒來監視多個輸入通道，你可以註冊多個通道使用一個選擇器，然後使用一個單獨的執行緒來“選擇”通道：這些通道里已經有可以處理的輸入，或者選擇已準備寫入的通道。這種選擇機制，使得一個單獨的執行緒很容易來管理多個通道。

NIO和IO如何影響應用程式的設計

無論您選擇IO或NIO工具箱，可能會影響您應用程式設計的以下幾個方面：

1. 對NIO或IO類的API呼叫。
2. 資料處理。
3. 用來處理資料的執行緒數。

API呼叫

當然，使用NIO的API呼叫時看起來與使用IO時有所不同，但這並不意外，因為並不是僅從一個InputStream逐位元組讀取，而是資料必須先讀入緩衝區再處理。

資料處理

使用純粹的NIO設計相較IO設計，資料處理也受到影響。

在IO設計中，我們從InputStream或 Reader逐位元組讀取資料。假設你正在處理一基於行的文字資料流，例如：

Name: Anna
Age: 25
Email: [email protected]
Phone: 1234567890

該文字行的流可以這樣處理：

InputStream input = ... ; // get the InputStream from the client socket
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String nameLine = reader.readLine();
String ageLine = reader.readLine();
String emailLine = reader.readLine();
String phoneLine = reader.readLine();

請注意處理狀態由程式執行多久決定。換句話說，一旦reader.readLine()方法返回，你就知道肯定文字行就已讀完， readline()阻塞直到整行讀完，這就是原因。你也知道此行包含名稱；同樣，第二個readline()呼叫返回的時候，你知道這行包含年齡等。

正如你可以看到，該處理程式僅在有新資料讀入時執行，並知道每步的資料是什麼。一旦正在執行的執行緒已處理過讀入的某些資料，該執行緒不會再回退資料（大多如此）。下圖也說明了這條原則：


Java IO: 從一個阻塞的流中讀資料

而一個NIO的實現會有所不同，下面是一個簡單的例子：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);

注意第二行，從通道讀取位元組到ByteBuffer。當這個方法呼叫返回時，你不知道你所需的所有資料是否在緩衝區內。你所知道的是，該緩衝區包含一些位元組，這使得處理有點困難。

假設第一次read(buffer)呼叫後，讀入緩衝區的資料只有半行，例如，“Name:An”，你能處理資料嗎？顯然不能，需要等待，直到整行資料讀入快取，在此之前，對資料的任何處理毫無意義。

所以，你怎麼知道是否該緩衝區包含足夠的資料可以處理呢？好了，你不知道。發現的方法只能檢視緩衝區中的資料。其結果是，在你知道所有資料都在緩衝區裡之前，你必須檢查幾次緩衝區的資料。這不僅效率低下，而且可以使程式設計方案雜亂不堪。例如：

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);
while(! bufferFull(bytesRead) ) {
    bytesRead = inChannel.read(buffer);
}

bufferFull()方法必須跟蹤有多少資料讀入緩衝區，並返回真或假，這取決於緩衝區是否已滿。換句話說，如果緩衝區準備好被處理，那麼表示緩衝區滿了。

bufferFull()方法掃描緩衝區，但必須保持在bufferFull()方法被呼叫之前狀態相同。如果沒有，下一個讀入緩衝區的資料可能無法讀到正確的位置。這是不可能的，但卻是需要注意的又一問題。

如果緩衝區已滿，它可以被處理。如果它不滿，並且在你的實際案例中有意義，你或許能處理其中的部分資料。但是許多情況下並非如此。

下圖展示了“緩衝區資料迴圈就緒”：



Java NIO:從一個通道里讀資料，直到所有的資料都讀到緩衝區裡

總結

NIO可讓您只使用一個（或幾個）單執行緒管理多個通道（網路連線或檔案），但付出的代價是解析資料可能會比從一個阻塞流中讀取資料更復雜。

如果需要管理同時開啟的成千上萬個連線，這些連線每次只是傳送少量的資料，例如聊天伺服器，實現NIO的伺服器可能是一個優勢。同樣，如果你需要維持許多開啟的連線到其他計算機上，如P2P網路中，使用一個單獨的執行緒來管理你所有出站連線，可能是一個優勢。一個執行緒多個連線的設計方案如下圖所示：



Java NIO: 單執行緒管理多個連線

如果你有少量的連線使用非常高的頻寬，一次傳送大量的資料，也許典型的IO伺服器實現可能非常契合。下圖說明了一個典型的IO伺服器設計：



Java IO: 一個典型的IO伺服器設計- 一個連線通過一個執行緒處理