Java NIO提供了與標準IO不同的IO工作方式：
Channels and Buffers（通道和緩衝區）：標準的IO基於位元組流和字元流進行操作的，而NIO是基於通道（Channel）和緩衝區（Buffer）進行操作，資料總是從通道讀取到緩衝區中，或從緩衝區寫入到通道中。
Asynchronous IO（非同步IO）：Java NIO可以讓你非同步的使用IO，例如：當執行緒從通道讀取資料到緩衝區時，執行緒還是可以進行其他事情。當資料被寫入到緩衝區時，執行緒可以繼續處理它。從緩衝區寫入通道也類似。
Selectors（選擇器）：Java NIO引入了選擇器的概念，選擇器用於監聽多個通道的事件（例如：連接打開，資料到達）。因此，單一的執行緒可以監聽多個資料通道。
以下就來詳細介紹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 還有個Mappedyteuffer，用來表示記憶體對映文件， 我也不打算在概述中說明。
Selector
Selector允許單線程處理多個Channel。如果你的應用程式開啟了多個連線（通道），但每個連線的流量都很低，使用Selector就會很方便。例如，在一個聊天伺服器中。
這是在一個單執行緒中使用一個Selector處理3個Channel的圖示：
要使用Selector，得向Selector註冊Channel，然後呼叫它的select()方法。這個方法會一直阻塞到某個註冊的通道有事件就緒。一旦這個方法返回，線程就可以處理這些事件，事件的例子有如新連接進來，數據接收等。
Java NIO vs. IO
（本部分原文地址，作者：Jakob Jenkov，譯者：郭蕾，校對：方騰飛）
當學習了Java NIO和IO的API後，一個問題馬上湧入腦海：
引用
我應該何時使用IO，何時使用NIO？在本文中，我會盡量清楚地解析Java NIO和IO的差異、它們的使用場景，以及它們如何影響您的程式碼設計。
Java NIO和IO的主要差異
下表總結了Java NIO和IO之間的主要差異，我會更詳細地描述表中每個部分的差異。
IO NIO
Stream oriented Buffer oriented
Blocking IO Non blocking IO
Selectors
面向流與面向緩衝
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工具箱，可能會影響您應用程式設計的以下幾個方面：
對NIO或IO類別的API呼叫。
數據處理。
用來處理資料的線程數。
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()呼叫返回的時候，你知道這行包含年齡等。 正如你可以看到，該處理程序僅在有新資料讀入時運行，並知道每個步驟的資料是什麼。一旦正在執行的執行緒已處理過讀入的某些數據，該執行緒就不會再回退資料（大多如此）。下圖也說明了這項原則：
從一個阻塞的流中讀數據
而一個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（）方法被呼叫之前狀態相同。如果沒有，下一個讀入緩衝區的資料可能無法讀到正確的位置。這是不可能的，但卻是需要注意的另一個問題。
如果緩衝區已滿，它可以被處理。如果它不滿，並且在你的實際案例中有意義，你或許能處理其中的部分數據。但是許多情況並非如此。下圖展示了「緩衝區資料循環就緒」：
從一個頻道讀取數據，直到所有的數據都讀到緩衝區裡
總結
NIO可讓您只使用一個（或幾個）單執行緒管理多個通道（網路連線或檔案），但付出的代價是解析資料可能會比從一個阻塞流讀取資料更複雜。
如果需要管理同時打開的成千上萬個連接，這些連接每次只是發送少量的數據，例如聊天伺服器，實現NIO的伺服器可能是一個優勢。同樣，如果你需要維持許多打開的連接到其他電腦上，如P2P網路中，使用一個單獨的線程來管理你所有出站連接，可能是一個優勢。一個線程多個連接的設計方案如下圖所示：
單線程管理多個連接
如果你有少量的連線使用非常高的頻寬，一次發送大量的數據，也許典型的IO伺服器實作可能非常契合。下圖說明了一個典型的IO伺服器設計：
一個典型的IO伺服器設計：
一個連接透過一個線程處理
頻道（Channel）
Java NIO的通道類似流，但又有些不同：
既可以從通道中讀取數據，又可以寫入數據到通道。但流的讀寫通常是單向的。
通道可以異步地讀寫。
頻道中的資料總是要先讀到一個Buffer，或是總是要從一個Buffer中寫入。
如同上面所說，從通道讀取資料到緩衝區，從緩衝區寫入資料到通道。如下圖所示：
Channel的實現
這些是Java NIO中最重要的通道的實作：
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讀寫資料一般遵循以下四個步驟：
寫入資料到Buffer
呼叫flip()方法
從Buffer中讀取數據
呼叫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, eg during parsing.
buffer.reset();//set position back to mark.
equals()與compareTo()方法
可以使用equals()和compareTo()方法兩個Buffer。
equals()
當滿足下列條件時，表示兩個Buffer相等：
有相同的型別（byte、char、int等）。
Buffer中剩餘的byte、char等的個數相等。
Buffer中所有剩餘的byte、char等都相同。
如你所見，equals只是比較Buffer的一部分，不是每一個在它裡面的元素都比較。實際上，它只比較Buffer中的剩餘元素。
compareTo()方法
compareTo()方法比較兩個Buffer的剩餘元素(byte、char等)， 若符合下列條件，則認為一個Buffer「小於」另一個Buffer：
第一個不相等的元素小於另一個Buffer中對應的元素。
所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少)。
（譯註：剩餘元素是從position到limit之間的元素）
分散（Scatter）/聚集（Gather）
（本部分原文地址，作者：Jakob Jenkov 譯者：郭蕾）
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能較好的處理動態消息。
通道之間的資料傳輸
（本部分原文地址，作者：Jakob Jenkov，譯者：郭蕾，校對：周泰）
在Java NIO中，如果兩個通道中有一個是FileChannel，那你可以直接將資料從一個channel（譯者註：channel中文常譯作通道）傳送到另一個channel。
transferFrom()
FileChannel的transferFrom()方法可以將資料從來源通道傳輸到FileChannel（譯者註：這個方法在JDK文件中的解釋為將位元組從給定的可讀取位元組通道傳輸到此通道的檔案中）。下面是一個簡單的例子：
複製代碼代碼如下:
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();
toChannel.transferFrom(position, count, fromChannel);
方法的輸入參數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）
（本部分原文鏈接，作者：Jakob Jenkov，譯者：浪跡v，校對：丁一）
Selector（選擇器）是Java NIO中能夠偵測一到多個NIO通道，並且能夠知曉通道是否為諸如讀寫事件做好準備的元件。這樣，一個單獨的執行緒可以管理多個channel，從而管理多個網路連線。
(1)為什麼要使用Selector?
僅用單一線程來處理多個Channels的好處是，只需要更少的線程來處理通道。事實上，可以只用一個執行緒處理所有的通道。對於作業系統來說，執行緒之間上下文切換的開銷很大，而且每個執行緒都要佔用系統的一些資源（如記憶體）。因此，使用的線程越少越好。
但是，需要記住，現代的作業系統和CPU在多任務方面表現的越來越好，所以多執行緒的開銷隨著時間的推移，變得越來越小了。實際上，如果一個CPU有多個內核，不使用多任務可能是在浪費CPU能力。不管怎麼說，關於那種設計的討論應該放在另一篇不同的文章中。在這裡，只要知道使用Selector能夠處理多個通道就足夠了。
下面是單執行緒使用一個Selector處理3個channel的範例圖：
(2)Selector的創建
透過呼叫Selector.open()方法建立一個Selector，如下：
複製代碼代碼如下:
Selector selector = Selector.open();
(3) 向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時對什麼事件感興趣。可以監聽四種不同類型的事件：
Connect
Accept
Read
Write
通道觸發了一個事件意思是該事件已經就緒。所以，某個channel成功連接到另一個伺服器稱為「連線就緒」。一個server socket channel準備好接收新進入的連線稱為「接收就緒」。一個有資料可讀的通道可以說是「讀就緒」。等待寫資料的通道可以說是「寫就緒」。
這四種事件用SelectionKey的四個常數來表示：
SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE
如果你對不只一種事件感興趣，那麼可以用「位元或」操作符將常數連接起來，如下：
複製代碼代碼如下:
int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
在下面還會繼續提到interest集合。
(4)SelectionKey
在上一小節中，當向Selector註冊Channel時，register()方法會傳回一個SelectionKey物件。這個物件包含了一些你感興趣的屬性：
interest集合
ready集合
Channel
Selector
附加的物件（可選）
下面我會描述這些屬性。
interest集合
就像向Selector註冊通道一節中所描述的，interest集合是你所選擇的感興趣的事件集合。可以透過SelectionKey讀寫interest集合，像這樣：
複製代碼代碼如下:
int interestSet = selectionKey.interess();
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很簡單。如下：
複製代碼代碼如下:
Channelchannel= 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);
(5)透過Selector選擇通道
一旦向Selector註冊了一或多個通道，就可以呼叫幾個重載的select()方法。這些方法會傳回你所感興趣的事件（如連接、接受、讀取或寫入）已經準備就緒的那些通道。換句話說，如果你對「讀取就緒」的通道感興趣，select()方法會傳回那些讀事件已經就緒的通道。
下面是select()方法：
int select()
int select(long timeout)
int selectNow()
select()阻塞到至少有一個頻道在你註冊的事件上就緒了。
select(long timeout)和select()一樣，除了最長會阻塞timeout毫秒(參數)。
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.<tuihighlight><a href="javascript:;" style="display:inline;float:none;position:inherit;cursor:pointer;color:#7962D5;text-decoration:underline;">remove</a ></tuihighlight>();
}
這個循環遍歷已選擇鍵集中的每個鍵，並偵測各個鍵所對應的通道的就緒事件。
注意每次迭代末尾的keyIterator.remove()呼叫。 Selector不會自行從已選擇鍵集中移除SelectionKey實例。必須在處理完頻道時自行移除。下次該通道變成就緒時，Selector會再次將其放入已選擇鍵集中。
SelectionKey.channel()方法回傳的通道需要轉型成你要處理的類型，例如ServerSocketChannel或SocketChannel等。
(6)wakeUp()
某個執行緒呼叫select()方法後阻塞了，即使沒有通道已經就緒，也有辦法讓其從select()方法傳回。只要讓它執行緒在第一個執行緒呼叫select()方法的那個物件上呼叫Selector.wakeup()方法即可。阻塞在select()方法上的執行緒會立刻回傳。
如果有其它執行緒呼叫了wakeup()方法，但目前沒有執行緒阻塞在select()方法上，下個呼叫select()方法的執行緒會立即「醒來（wake up）」。
(7)close()
用完Selector後呼叫其close()方法會關閉該Selector，且使註冊到該Selector上的所有SelectionKey實例無效。通道本身並不會關閉。
(8)完整的範例
這裡有一個完整的範例，打開一個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.<tuihighlight><a href="javascript:;" style="display:inline;float:none;position:inherit;cursor:pointer;color:#7962D5;text-decoration:underline;">remove</a ></tuihighlight>();
}
}
文件頻道
（本部分原文鏈接，作者：Jakob Jenkov，譯者：週泰，校對：丁一）
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);
Socket 頻道
（本部分原文鏈接，作者：Jakob Jenkov，譯者：鄭玉婷，校對：丁一）
Java NIO中的SocketChannel是一個連接到TCP網路套接字的通道。可以透過以下2種方式建立SocketChannel：
開啟一個SocketChannel並連接到網路上的某台伺服器。
一個新連線到達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的搭配使用會在後面詳講。
ServerSocket 通道
（本部分原文鏈接，作者：Jakob Jenkov，譯者：鄭玉婷，校對：丁一）
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...
}
}
Datagram 頻道
（本部分原文鏈接，作者：Jakob Jenkov，譯者：鄭玉婷，校對：丁一）
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）
（本部分原文鏈接，作者：Jakob Jenkov，譯者：黃忠，校對：丁一）
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()) {
<b>sinkChannel.write(buf);</b>
}
[code]
從管道讀取數據
從讀取管道的數據，需要存取source通道，像這樣：
[code]
Pipe.SourceChannel sourceChannel = pipe.source();
呼叫source通道的read()方法來讀取數據，像這樣：
複製代碼代碼如下:
ByteBuffer buf = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buf);
read()方法傳回的int值會告訴我們多少位元組被讀進了緩衝區。