摘要：當數(shù)據(jù)被寫入到緩沖區(qū)時，線程可以繼續(xù)處理它。當滿足下列條件時，表示兩個相等有相同的類型等。調(diào)用通道的方法時，可能會導致線程暫時阻塞，就算通道處于非阻塞模式也不例外。當一個通道關(guān)閉時，休眠在該通道上的所有線程都將被喚醒并收到一個異常。

I/O和NIO的區(qū)別在于數(shù)據(jù)的打包和傳輸方式。

I/O流的方式處理數(shù)據(jù)

NIO塊的方式處理數(shù)據(jù)

面向流 的 I/O 系統(tǒng)一次一個字節(jié)地處理數(shù)據(jù)。一個輸入流產(chǎn)生一個字節(jié)的數(shù)據(jù)，一個輸出流消費一個字節(jié)的數(shù)據(jù)。為流式數(shù)據(jù)創(chuàng)建過濾器非常容易。鏈接幾個過濾器，以便每個過濾器只負責單個復雜處理機制的一部分，這樣也是相對簡單的。面向流的 I/O 通常相當慢。

一個 面向塊 的 I/O 系統(tǒng)以塊的形式處理數(shù)據(jù)。每一個操作都在一步中產(chǎn)生或者消費一個數(shù)據(jù)塊。按塊處理數(shù)據(jù)比按(流式的)字節(jié)處理數(shù)據(jù)要快得多。但是面向塊的I/O比較復雜。NIO的主要應用在高性能、高容量服務端應用程序。

1、Channels and Buffers（通道和緩沖區(qū)）
標準的IO基于字節(jié)流和字符流進行操作的，而NIO是基于通道（Channel）和緩沖區(qū)（Buffer）進行操作，數(shù)據(jù)總是從通道讀取到緩沖區(qū)中，或者從緩沖區(qū)寫入到通道中。

2、Non-blocking IO（非阻塞IO）
Java NIO可以非阻塞的方式使用IO，例如：當線程從通道讀取數(shù)據(jù)到緩沖區(qū)時，線程還是可以進行其他事情。當數(shù)據(jù)被寫入到緩沖區(qū)時，線程可以繼續(xù)處理它。從緩沖區(qū)寫入通道也類似。

3、Selectors（選擇器）
Java NIO引入了選擇器的概念，選擇器用于監(jiān)聽多個通道的事件（比如：連接打開，數(shù)據(jù)到達）。因此，單個的線程可以監(jiān)聽多個數(shù)據(jù)通道。

通道和緩沖區(qū)是 NIO 中的核心對象，幾乎在每一個 I/O 操作中都要使用它們。

一個 Buffer 實質(zhì)上是一個容器對象，它包含一些要寫入或者剛讀出的數(shù)據(jù)。

在 NIO 庫中，所有數(shù)據(jù)都是用緩沖區(qū)處理的。在讀取數(shù)據(jù)時，它是直接讀到緩沖區(qū)中的。在寫入數(shù)據(jù)時，它是寫入到緩沖區(qū)中的。任何時候訪問 NIO 中的數(shù)據(jù)，您都是將它放到緩沖區(qū)中。

緩沖區(qū)實質(zhì)上就是一個數(shù)組，通常它是一個字節(jié)數(shù)組，但是也可以使用其他種類的數(shù)組。但它不僅僅是一個數(shù)組，緩沖區(qū)還提供了對數(shù)據(jù)的結(jié)構(gòu)化訪問，而且還可以跟蹤系統(tǒng)的讀/寫進程。

最常用的緩沖區(qū)類型是 ByteBuffer。一個 ByteBuffer 可以在其底層字節(jié)數(shù)組上進行 get/set 操作(即字節(jié)的獲取和設置)。

ByteBuffer 不是 NIO 中唯一的緩沖區(qū)類型。事實上，對于每一種基本 Java 類型都有一種緩沖區(qū)類型：

Buffer抽象類中提供了需要處理的方法類型。

使用Buffer讀寫數(shù)據(jù)一般遵循以下四個步驟：

寫入數(shù)據(jù)到Buffer

調(diào)用flip()方法

從Buffer中讀取數(shù)據(jù)

調(diào)用clear()方法或者compact()方法

當向buffer寫入數(shù)據(jù)時，buffer會記錄下寫了多少數(shù)據(jù)。一旦要讀取數(shù)據(jù)，需要通過flip()方法將Buffer從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有數(shù)據(jù)。一旦讀完了所有的數(shù)據(jù)，就需要清空緩沖區(qū)，讓它可以再次被寫入。

有兩種方式能清空緩沖區(qū)：調(diào)用clear()或compact()方法。

clear()方法會清空整個緩沖區(qū)。compact()方法只會清除已經(jīng)讀過的數(shù)據(jù)。任何未讀的數(shù)據(jù)都被移到緩沖區(qū)的起始處，新寫入的數(shù)據(jù)將放到緩沖區(qū)未讀數(shù)據(jù)的后面。

try (RandomAccessFile aFile = new RandomAccessFile("F:1.txt", "rw")) {
            //從RandomAccesFile獲取通道
            FileChannel inChannel = aFile.getChannel();
            
            //創(chuàng)建一個緩沖區(qū)并在其中放入一些數(shù)據(jù)
            ByteBuffer buf = ByteBuffer.allocate(48);
            int bytesRead = inChannel.read(buf); //read into buffer.
            
            //檢查狀態(tài)
            while (bytesRead != -1) {
                //flip() 方法讓緩沖區(qū)可以將新讀入的數(shù)據(jù)寫入另一個通道。
                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);
            }
        }

緩沖區(qū)本質(zhì)上是一塊可以寫入數(shù)據(jù)，然后可以從中讀取數(shù)據(jù)的內(nèi)存。這塊內(nèi)存被包裝成NIO Buffer對象，并提供了一組方法，用來方便的訪問該塊內(nèi)存。

緩沖區(qū)對象有三個基本屬性：

容量Capacity：緩沖區(qū)能容納的數(shù)據(jù)元素的最大數(shù)量，在緩沖區(qū)創(chuàng)建時設定，無法更改

上界Limit：表明還有多少數(shù)據(jù)需要取出(在從緩沖區(qū)寫入通道時)，或者還有多少空間可以放入數(shù)據(jù)(在從通道讀入緩沖區(qū)時)，limit不能大于capacity

位置Position：下一個要被讀或?qū)懙脑氐乃饕?/p>

這三個變量一起可以跟蹤緩沖區(qū)的狀態(tài)和它所包含的數(shù)據(jù)。

四個屬性總是遵循這樣的關(guān)系：0<=mark<=position<=limit<=capacity。下圖是新創(chuàng)建的容量為10的緩沖區(qū)邏輯視圖：

寫入模式
buffer.put((byte)"H").put((byte)"e").put((byte)"l").put((byte)"l").put((byte)"o");
五次調(diào)用put后的緩沖區(qū)：

此時，limit表示還有多少空間可以放入數(shù)據(jù)。position最大可為capacity-1。

讀取模式
現(xiàn)在緩沖區(qū)滿了，我們必須將其清空。我們想把這個緩沖區(qū)傳遞給一個通道，以使內(nèi)容能被全部寫出，但現(xiàn)在執(zhí)行g(shù)et()無疑會取出未定義的數(shù)據(jù)。我們必須將posistion設為0，然后通道就會從正確的位置開始讀了，但讀到哪算讀完了呢？這正是limit引入的原因，它指明緩沖區(qū)有效內(nèi)容的未端。這個操作 在緩沖區(qū)中叫做翻轉(zhuǎn)：buffer.flip()。

flip這個方法做兩件非常重要的事：

將 limit 設置為當前 position。

將 position 設置為 0。

rewind操作與flip相似，但不影響limit。

clear
最后一步是調(diào)用緩沖區(qū)的 clear() 方法。這個方法重設緩沖區(qū)以便接收更多的字節(jié)。
Clear 做兩種非常重要的事情：

1.將 limit 設置為與 capacity 相同。
2.設置 position 為 0。

clear()與compact()區(qū)別
1、clear()方法，position將被設回0，limit被設置成 capacity的值。Buffer中有一些未讀的數(shù)據(jù)，調(diào)用clear()方法，數(shù)據(jù)將“被遺忘”
2、compact()方法將所有未讀的數(shù)據(jù)拷貝到Buffer起始處。然后將position設到最后一個未讀元素正后面。limit屬性依然像clear()方法一樣，設置成capacity。

在能夠讀和寫之前，必須有一個緩沖區(qū)。要創(chuàng)建緩沖區(qū)，必須要進行分配,。我們使用靜態(tài)方法 allocate() 來分配緩沖區(qū),每一個Buffer類都有一個allocate方法。

//分配48字節(jié)capacity的ByteBuffer的例子。
ByteBuffer buf = ByteBuffer.allocate(48);

//分配一個可存儲1024個字符的CharBuffer：
CharBuffer buf = CharBuffer.allocate(1024);

寫數(shù)據(jù)到Buffer有兩種方式：

從Channel寫到Buffer。

通過Buffer的put()方法寫到Buffer里。

//從Channel寫到Buffer
int bytesRead = inChannel.read(buf); //read into buffer.

//通過put方法寫B(tài)uffer的例子：
buf.put(127);

從Buffer中讀取數(shù)據(jù)有兩種方式：

從Buffer讀取數(shù)據(jù)到Channel。

使用get()方法從Buffer中讀取數(shù)據(jù)。

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

//使用get()方法從Buffer中讀取數(shù)據(jù)
byte aByte = buf.get();

get方法有很多版本，允許你以不同的方式從Buffer中讀取數(shù)據(jù)。例如，從指定position讀取，或者從Buffer中讀取數(shù)據(jù)到字節(jié)數(shù)組。

rewind()方法

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

mark()與reset()

通過調(diào)用Buffer.mark()方法，可以標記Buffer中的一個特定position。之后可以通過調(diào)用Buffer.reset()方法恢復到這個position。

equals()與compareTo()方法

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

equals()

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

有相同的類型（byte、char、int等）。

Buffer中剩余的byte、char等的個數(shù)相等。

Buffer中所有剩余的byte、char等都相同。

equals只是比較Buffer的一部分，不是每一個在它里面的元素都比較。實際上，它只比較Buffer中的剩余元素。

compareTo()

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

第一個不相等的元素小于另一個Buffer中對應的元素

第一個Buffer的元素個數(shù)比另一個少

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

既可以從通道中讀取數(shù)據(jù)，又可以寫數(shù)據(jù)到通道。但流的讀寫通常是單向的。

通道可以異步地讀寫。

通道中的數(shù)據(jù)總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。

FileChannel 從文件中讀寫數(shù)據(jù)。

DatagramChannel 能通過UDP讀寫網(wǎng)絡中的數(shù)據(jù)。

SocketChannel 能通過TCP讀寫網(wǎng)絡中的數(shù)據(jù)。

ServerSocketChannel可以監(jiān)聽新進來的TCP連接，像Web服務器那樣。對每一個新進來的連接都會創(chuàng)建一個SocketChannel。

與緩沖區(qū)不同，通道不能被重復使用；關(guān)閉通道后，通道將不再連接任何東西，任何的讀或?qū)懖僮鞫紩е翪losedChannelException。

調(diào)用通道的close()方法時，可能會導致線程暫時阻塞，就算通道處于非阻塞模式也不例外。如果通道實現(xiàn)了InterruptibleChannel接 口，那么阻塞在該通道上的一個線程被中斷時，該通道將被關(guān)閉，被阻塞線程也會拋出ClosedByInterruptException異常。

當一個通道 關(guān)閉時，休眠在該通道上的所有線程都將被喚醒并收到一個AsynchronousCloseException異常。

scatter/gather用于描述從Channel中讀取或者寫入到Channel的操作。

分散（scatter）從Channel中讀取是指在讀操作時將讀取的數(shù)據(jù)寫入多個buffer中。因此，Channel將從Channel中讀取的數(shù)據(jù)"分散（scatter）"到多個Buffer中。

聚集（gather）寫入Channel是指在寫操作時將多個buffer的數(shù)據(jù)寫入同一個Channel，因此，Channel 將多個Buffer中的數(shù)據(jù)"聚集（gather）"后發(fā)送到Channel。

scatter / gather經(jīng)常用于需要將傳輸?shù)臄?shù)據(jù)分開處理的場合，例如傳輸一個由消息頭和消息體組成的消息，你可能會將消息體和消息頭分散到不同的buffer中，這樣你可以方便的處理消息頭和消息體。

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);

ByteBuffer[] bufferArray = { header, body };

channel.read(bufferArray);

buffer首先被插入到數(shù)組，然后再將數(shù)組作為channel.read() 的輸入?yún)?shù)。read()方法按照buffer在數(shù)組中的順序?qū)腸hannel中讀取的數(shù)據(jù)寫入到buffer，當一個buffer被寫滿后，channel緊接著向另一個buffer中寫。

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

Gathering Writes是指數(shù)據(jù)從多個buffer寫入到同一個channel。如下圖描述：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);

//write data into buffers

ByteBuffer[] bufferArray = { header, body };

channel.write(bufferArray);

buffers數(shù)組是write()方法的入?yún)?，write()方法會按照buffer在數(shù)組中的順序，將數(shù)據(jù)寫入到channel，注意只有position和limit之間的數(shù)據(jù)才會被寫入。因此，如果一個buffer的容量為128byte，但是僅僅包含58byte的數(shù)據(jù)，那么這58byte的數(shù)據(jù)將被寫入到channel中。因此與Scattering Reads相反，Gathering Writes能較好的處理動態(tài)消息。

Java NIO中的FileChannel是一個連接到文件的通道?？梢酝ㄟ^文件通道讀寫文件。FileChannel無法設置為非阻塞模式，它總是運行在阻塞模式下。

因為無法保證write()方法一次能向FileChannel寫入多少字節(jié)，因此需要重復調(diào)用write()方法，直到Buffer中已經(jīng)沒有尚未寫入通道的字節(jié)。

//通過inputstream或者RandomAccessFile，打開FileChannel
RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");
FileChannel inChannel = aFile.getChannel();

//往buffer里面讀取數(shù)據(jù)
ByteBuffer buf = ByteBuffer.allocate(48);

//int值表示了有多少字節(jié)被讀到了Buffer中。如果返回-1，表示到了文件末尾。
int bytesRead = inChannel.read(buf);

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后必須將其關(guān)閉
channel.close();

Selector（選擇器）是Java NIO中能夠檢測一到多個NIO通道，并能夠知曉通道是否為諸如讀寫事件做好準備的組件。這樣，一個多帶帶的線程可以管理多個channel，從而管理多個網(wǎng)絡連接。

對于操作系統(tǒng)來說，線程之間上下文切換的開銷很大，而且每個線程都要占用系統(tǒng)的一些資源（如內(nèi)存）。因此，使用的線程越少越好。

使用Selector.open()方法創(chuàng)建Selector，為了將Channel和Selector配合使用，必須將channel注冊到selector上。通過SelectableChannel.register()方法來實現(xiàn)。如下所示

//創(chuàng)建Selector
Selector selector = Selector.open();

//向Selector注冊通道
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

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

register()方法的第二個參數(shù)。這是一個“interest集合”，意思是在通過Selector監(jiān)聽Channel時對什么事件感興趣。可以監(jiān)聽四種不同類型的事件：

通道觸發(fā)了一個事件意思是該事件已經(jīng)就緒。所以，某個channel成功連接到另一個服務器稱為“連接就緒”。一個server socket channel準備好接收新進入的連接稱為“接收就緒”。一個有數(shù)據(jù)可讀的通道可以說是“讀就緒”。等待寫數(shù)據(jù)的通道可以說是“寫就緒”。

當向Selector注冊Channel時，register()方法會返回一個SelectionKey對象。這個對象包含了一些屬性：

interest集合

ready集合

Channel

Selector

附加的對象

interest集合

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 集合是通道已經(jīng)準備就緒的操作的集合。在一次選擇(Selection)之后，會首先訪問這個ready set?？梢赃@樣訪問ready集合：

int readySet = selectionKey.readyOps();

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

可以用像檢測interest集合那樣的方法，來檢測channel中什么事件或操作已經(jīng)就緒。但是，也可以使用以上四個方法，它們都會返回一個布爾類型。

Channel + Selector

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

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

附加的對象
可以將一個對象或者更多信息附著到SelectionKey上，可以方便識別某個給定的通道。例如，可以附加 與通道一起使用的Buffer，或是包含聚集數(shù)據(jù)的某個對象。使用方法如下：

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

//用register()方法向Selector注冊Channel的時候附加對象
SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

一旦向Selector注冊了一或多個通道，就可以調(diào)用select()方法，選擇已經(jīng)準備就緒的事件的通道類型。
select方法

int select() //阻塞到至少有一個通道在你注冊的事件上就緒了
int select(long timeout)//和select()一樣，除了最長會阻塞timeout毫秒(參數(shù))。
int selectNow()//不會阻塞，不管什么通道就緒都立刻返回

select()方法返回的int值表示有多少通道已經(jīng)就緒,然后可以通過調(diào)用selector的selectedKeys()方法，訪問“已選擇鍵集（selected key set）”中的就緒通道。如下所示：

//訪問“已選擇鍵集（selected key set）”中的就緒通道
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();
}

這個循環(huán)遍歷已選擇鍵集中的每個鍵，并檢測各個鍵所對應的通道的就緒事件。

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

wakeUp()

某個線程調(diào)用select()方法后阻塞了，即使沒有通道已經(jīng)就緒，也有辦法讓其從select()方法返回。只要讓其它線程在第一個線程調(diào)用select()方法的那個對象上調(diào)用Selector.wakeup()方法即可。阻塞在select()方法上的線程會立馬返回。

如果有其它線程調(diào)用了wakeup()方法，但當前沒有線程阻塞在select()方法上，下個調(diào)用select()方法的線程會立即“醒來（wake up）”。

close()

用完Selector后調(diào)用其close()方法會關(guān)閉該Selector，且使注冊到該Selector上的所有SelectionKey實例無效。通道本身并不會關(guān)閉。

管道是2個線程之間的單向數(shù)據(jù)連接。Pipe有一個source通道和一個sink通道。數(shù)據(jù)會被寫到sink通道，從source通道讀取。

原理圖如下：

//Pipe.open()方法打開管道
Pipe pipe = Pipe.open();

//訪問sink通道,向管道寫數(shù)據(jù)
Pipe.SinkChannel sinkChannel = pipe.sink();

//調(diào)用SinkChannel的write()方法，將數(shù)據(jù)寫入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();

//調(diào)用source通道的read()方法來讀取數(shù)據(jù)
ByteBuffer buf = ByteBuffer.allocate(48);

//read()方法返回的int值表示多少字節(jié)被讀進了緩沖區(qū)
int bytesRead = sourceChannel.read(buf);

參考資料引用

1、NIO 入門
2、Java NIO教程
3、理解Java NIO