歸納:
原文中說了最重要的3個概念，
Channel 通道
Buffer 緩沖區
Selector 選擇器
其中Channel對應以前的流，Buffer不是什麼新東西，Selector是因為nio可以使用異步的非堵塞模式才加入的東西。
以前的流總是堵塞的，一個線程隻要對它進行操作，其它操作就會被堵塞，也就相當于水管沒有閥門，你伸手接水的時候，不管水到了沒有，你就都隻能耗在接水（流）上。
nio 的Channel的加入，相當于增加了水龍頭（有閥門），雖然一個時刻也隻能接一個水管的水，但依賴輪換政策，在水量不大的時候，各個水管裡流出來的水， 都可以得到妥善接納，這個關鍵之處就是增加了一個接水工，也就是Selector，他負責協調，也就是看哪根水管有水了的話，在目前水管的水接到一定程度 的時候，就切換一下：臨時關上目前水龍頭，試着打開另一個水龍頭（看看有沒有水）。
當其他人需要用水的時候，不是直接去接水，而是事前提了一個水桶給接水工，這個水桶就是Buffer。也就是，其他人雖然也可能要等，但不會在現場等，而是回家等，可以做其它事去，水接滿了，接水工會通知他們。
這其實也是非常接近目前社會分工細化的現實，也是統分利用現有資源達到并發效果的一種很經濟的手段，而不是動不動就來個并行處理，雖然那樣是最簡單的，但也是最浪費資源的方式。
-------------------------------------
附：原文
Java NIO（New IO）是從Java 1.4版本開始引入的一個新的IO API，可以替代标準的Java IO API。本系列教程将有助于你學習和了解Java NIO。感謝并發程式設計網的翻譯和投遞。
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 vs. IO
- 通道（Channel）
- 緩沖區（Buffer）
- 分散（Scatter）/聚集（Gather）
- 通道之間的資料傳輸
- 選擇器（Selector）
- 檔案通道
- Socket 通道
- ServerSocket 通道
- Datagram 通道
- 管道（Pipe）
Java NIO
（本部分原文連結，作者：Jakob Jenkov， 譯者：airu，校對：丁一）
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
（本部分原文位址，作者：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 |
面向流與面向緩沖
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
該文本行的流可以這樣處理：
Java代碼
- 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”，你能處理資料嗎？顯然不能，需要等待，直到整行資料讀入緩存，在此之前，對資料的任何處理毫無意義。
是以，你怎麼知道是否該緩沖區包含足夠的資料可以處理呢？好了，你不知道。發現的方法隻能檢視緩沖區中的資料。其結果是，在你知道所有資料都在緩沖區裡之前，你必須檢查幾次緩沖區的資料。這不僅效率低下，而且可以使程式設計方案雜亂不堪。例如：
- while(! bufferFull(bytesRead) ) {
- bytesRead = inChannel.read(buffer);
- }
bufferFull()方法必須跟蹤有多少資料讀入緩沖區，并傳回真或假，這取決于緩沖區是否已滿。換句話說，如果緩沖區準備好被處理，那麼表示緩沖區滿了。
bufferFull()方法掃描緩沖區，但必須保持在bufferFull（）方法被調用之前狀态相同。如果沒有，下一個讀入緩沖區的資料可能無法讀到正确的位置。這是不可能的，但卻是需要注意的又一問題。
如果緩沖區已滿，它可以被處理。如果它不滿，并且在你的實際案例中有意義，你或許能處理其中的部分資料。但是許多情況下并非如此。下圖展示了“緩沖區資料循環就緒”：
從一個通道裡讀資料，直到所有的資料都讀到緩沖區裡
總結
NIO可讓您隻使用一個（或幾個）單線程管理多個通道（網絡連接配接或檔案），但付出的代價是解析資料可能會比從一個阻塞流中讀取資料更複雜。
如果需要管理同時打開的成千上萬個連接配接，這些連接配接每次隻是發送少量的資料，例如聊天伺服器，實作NIO的伺服器可能是一個優勢。同樣，如果你需要 維持許多打開的連接配接到其他計算機上，如P2P網絡中，使用一個單獨的線程來管理你所有出站連接配接，可能是一個優勢。一個線程多個連接配接的設計方案如下圖所示：
單線程管理多個連接配接
如果你有少量的連接配接使用非常高的帶寬，一次發送大量的資料，也許典型的IO伺服器實作可能非常契合。下圖說明了一個典型的IO伺服器設計：
一個典型的IO伺服器設計：一個連接配接通過一個線程處理
Java NIO
（本部分原文連結，作者：Jakob Jenkov，譯者：airu，校對：丁一）
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的更多細節。
Java NIO
Java NIO中的Buffer用于和NIO通道進行互動。如你所知，資料是從通道讀入緩沖區，從緩沖區寫入到通道中的。
緩沖區本質上是一塊可以寫入資料，然後可以從中讀取資料的記憶體。這塊記憶體被包裝成NIO Buffer對象，并提供了一組方法，用來友善的通路該塊記憶體。
Buffer的基本用法
使用Buffer讀寫資料一般遵循以下四個步驟：
- 寫入資料到Buffer
- 調用flip()方法
- 從Buffer中讀取資料
- 調用clear()方法或者compact()方法
當向buffer寫入資料時，buffer會記錄下寫了多少資料。一旦要讀取資料，需要通過flip()方法将Buffer從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有資料。
一旦讀完了所有的資料，就需要清空緩沖區，讓它可以再次被寫入。有兩種方式能清空緩沖區：調用clear()或compact()方法。 clear()方法會清空整個緩沖區。compact()方法隻會清除已經讀過的資料。任何未讀的資料都被移到緩沖區的起始處，新寫入的資料将放到緩沖區 未讀資料的後面。
下面是一個使用Buffer的例子：
- //create buffer with capacity of 48 bytes
- int bytesRead = inChannel.read(buf); //read into buffer.
- 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);
Buffer的capacity,position和limit
為了了解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類型：
- MappedByteBuffer
如你所見，這些Buffer類型代表了不同的資料類型。換句話說，就是可以通過char，short，int，long，float 或 double類型來操作緩沖區中的位元組。
MappedByteBuffer 有些特别，在涉及它的專門章節中再講。
Buffer的配置設定
要想獲得一個Buffer對象首先要進行配置設定。 每一個Buffer類都有一個allocate方法。下面是一個配置設定48位元組capacity的ByteBuffer的例子。
這是配置設定一個可存儲1024個字元的CharBuffer：
- CharBuffer buf = CharBuffer.allocate(1024);
向Buffer中寫資料
寫資料到Buffer有兩種方式：
- 從Channel寫到Buffer。
- 通過Buffer的put()方法寫到Buffer裡。
從Channel寫到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相等：
- 有相同的類型（byte、char、int等）。
- Buffer中剩餘的byte、char等的個數相等。
- Buffer中所有剩餘的byte、char等都相同。
如你所見，equals隻是比較Buffer的一部分，不是每一個在它裡面的元素都比較。實際上，它隻比較Buffer中的剩餘元素。
compareTo()方法
compareTo()方法比較兩個Buffer的剩餘元素(byte、char等)， 如果滿足下列條件，則認為一個Buffer“小于”另一個Buffer：
- 第一個不相等的元素小于另一個Buffer中對應的元素。
- 所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少)。
（譯注：剩餘元素是從 position到limit之間的元素）
Java NIO
（本部分原文位址，作者：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。如下圖描述：
- //write data into buffers
- channel.write(bufferArray);
buffers數組是write()方法的入參，write()方法會按照buffer在數組中的順序，将資料寫入到channel，注意隻有 position和limit之間的資料才會被寫入。是以，如果一個buffer的容量為128byte，但是僅僅包含58byte的資料，那麼這 58byte的資料将被寫入到channel中。是以與Scattering Reads相反，Gathering Writes能較好的處理動态消息。
Java NIO
（本部分原文位址，作者：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中。下面是一個簡單的例子：
- fromChannel.transferTo(position, count, toChannel);
是不是發現這個例子和前面那個例子特别相似？除了調用方法的FileChannel對象不一樣外，其他的都一樣。
上面所說的關于SocketChannel的問題在transferTo()方法中同樣存在。SocketChannel會一直傳輸資料直到目标buffer被填滿。
Java NIO
（本部分原文連結，作者：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.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);
(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()方法通路這些對象。
可以周遊這個已選擇的鍵集合來通路就緒的通道。如下：
- 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 class="tuihighlight"><a href="javascript:;" style="display:inline;float:none;position:inherit;cursor:pointer;color:#7962D5;text-decoration:underline;" onclick="return false;">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的四種事件（接受，連接配接，讀，寫）是否就緒。
- 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()) {
Java NIO
（本部分原文連結，作者：Jakob Jenkov，譯者：周泰，校對：丁一）
Java NIO中的FileChannel是一個連接配接到檔案的通道。可以通過檔案通道讀寫檔案。
FileChannel無法設定為非阻塞模式，它總是運作在阻塞模式下。
打開FileChannel
在使用FileChannel之前，必須先打開它。但是，我們無法直接打開一個FileChannel，需要通過使用一個 InputStream、OutputStream或RandomAccessFile來擷取一個FileChannel執行個體。下面是通過 RandomAccessFile打開FileChannel的示例：
從FileChannel讀取資料
調用多個read()方法之一從FileChannel中讀取資料。如：
首先，配置設定一個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();
- buf.put(newData.getBytes());
- 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);
Java NIO
（本部分原文連結，作者：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()的方法之一。以下是例子：
- int bytesRead = socketChannel.read(buf);
首先，配置設定一個Buffer。從SocketChannel讀取到的資料将會放到這個Buffer中。
然後，調用SocketChannel.read()。該方法将資料從SocketChannel 讀到Buffer中。read()方法傳回的int值表示讀了多少位元組進Buffer裡。如果傳回的是-1，表示已經讀到了流的末尾（連接配接關閉了）。
寫入 SocketChannel
寫資料到SocketChannel用的是SocketChannel.write()方法，該方法以一個Buffer作為參數。示例如下：
注意SocketChannel.write()方法的調用是在一個while循環中的。Write()方法無法保證能寫多少位元組到SocketChannel。是以，我們重複調用write()直到Buffer沒有要寫的位元組為止。
非阻塞模式
可以設定 SocketChannel 為非阻塞模式（non-blocking mode）.設定之後，就可以在異步模式下調用connect(), read() 和write()了。
connect()
如果SocketChannel在非阻塞模式下，此時調用connect()，該方法可能在連接配接建立之前就傳回了。為了确定連接配接是否建立，可以調用finishConnect()的方法。像這樣：
- socketChannel.configureBlocking(false);
- while(! socketChannel.finishConnect() ){
- //wait, or do something else...
write()
非阻塞模式下，write()方法在尚未寫出任何内容時可能就傳回了。是以需要在循環中調用write()。前面已經有例子了，這裡就不贅述了。
read()
非阻塞模式下,read()方法在尚未讀取到任何資料時可能就傳回了。是以需要關注它的int傳回值，它會告訴你讀取了多少位元組。
非阻塞模式與選擇器
非阻塞模式與選擇器搭配會工作的更好，通過将一或多個SocketChannel注冊到Selector，可以詢問選擇器哪個通道已經準備好了讀取，寫入等。Selector與SocketChannel的搭配使用會在後面詳講。
Java NIO
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.close() 方法來關閉ServerSocketChannel. 如：
- serverSocketChannel.close();
監聽新進來的連接配接
通過 ServerSocketChannel.accept() 方法監聽新進來的連接配接。當 accept()方法傳回的時候，它傳回一個包含新進來的連接配接的 SocketChannel。是以，accept()方法會一直阻塞到有新連接配接到達。
通常不會僅僅隻監聽一個連接配接，在while循環中調用 accept()方法. 如下面的例子：
當然，也可以在while循環中使用除了true以外的其它退出準則。
ServerSocketChannel可以設定成非阻塞模式。在非阻塞模式下，accept() 方法會立刻傳回，如果還沒有新進來的連接配接，傳回的将是null。 是以，需要檢查傳回的SocketChannel是否是null。如：
- serverSocketChannel.configureBlocking(false);
- if(socketChannel != null){
- //do something with socketChannel...
Java NIO中的DatagramChannel是一個能收發UDP包的通道。因為UDP是無連接配接的網絡協定，是以不能像其它通道那樣讀取和寫入。它發送和接收的是資料包。
打開 DatagramChannel
下面是 DatagramChannel 的打開方式：
- DatagramChannel channel = DatagramChannel.open();
- channel.socket().bind(new InetSocketAddress(9999));
這個例子打開的 DatagramChannel可以在UDP端口9999上接收資料包。
接收資料
通過receive()方法從DatagramChannel接收資料，如：
- channel.receive(buf);
receive()方法會将接收到的資料包内容複制到指定的Buffer. 如果Buffer容不下收到的資料，多出的資料将被丢棄。
發送資料
通過send()方法從DatagramChannel發送資料，如:
- 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);
Java NIO
Java NIO 管道是2個線程之間的單向資料連接配接。Pipe有一個source通道和一個sink通道。資料會被寫到sink通道，從source通道讀取。
這裡是Pipe原理的圖示：
建立管道
通過Pipe.open()方法打開管道。例如：
- Pipe pipe = Pipe.open();
向管道寫資料
要向管道寫資料，需要通路sink通道。像這樣：
- Pipe.SinkChannel sinkChannel = pipe.sink();
通過調用SinkChannel的write()方法，将資料寫入SinkChannel,像這樣：
- <b>sinkChannel.write(buf);</b>
- Pipe.SourceChannel sourceChannel = pipe.source();
- Java NIO