java NIO 編程簡介

一 NIO簡介

Java NIO 是 java 1.4 之後新出的一套IO接口，這裏的的新是相對於原有標準的Java IO和Java Networking接口。NIO提供了一種完全不同的操作方式。

NIO中的N是Non-blocking，也可理解爲New。

它支持面向緩衝的，基於通道的I/O操作方法。隨着JDK 7的推出，NIO系統得到了擴展，爲文件系統功能和文件處理提供了增強的支持。由於NIO文件類支持的這些新的功能，NIO被廣泛應用於文件處理。

二 NIO的特性/NIO與IO區別

Java NIO基本組件如下：

1 Channels and Buffers（通道和緩衝區）

IO是面向流的，NIO是面向緩衝區的

標準的IO編程接口是面向字節流和字符流的。而NIO是面向通道和緩衝區的，數據總是從通道中讀到buffer緩衝區內，或者從buffer緩衝區寫入到通道中；（ NIO中的所有I/O操作都是通過一個通道開始的。）
Java IO面向流意味着每次從流中讀一個或多個字節，直至讀取所有字節，它們沒有被緩存在任何地方；
Java NIO是面向緩存的I/O方法。將數據讀入緩衝器，使用通道進一步處理數據。在NIO中，使用通道和緩衝區來處理I/O操作。

2 Non-blocking IO（非阻塞IO）

IO流是阻塞的，NIO流是不阻塞的。

Java NIO使我們可以進行非阻塞IO操作。比如說，單線程中從通道讀取數據到buffer，同時可以繼續做別的事情，當數據讀取到buffer中後，線程再繼續處理數據。寫數據也是一樣的。另外，非阻塞寫也是如此。一個線程請求寫入一些數據到某通道，但不需要等待它完全寫入，這個線程同時可以去做別的事情。
Java IO的各種流是阻塞的。這意味着，當一個線程調用read() 或 write()時，該線程被阻塞，直到有一些數據被讀取，或數據完全寫入。該線程在此期間不能再幹任何事情了

io 與 nio的區別如下:

IO	NIO
面向流(Stream Oriented)	面向緩衝區(Buffer Oriented)
阻塞IO(Blocking IO)	非阻塞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的選擇器允許一個單獨的線程來監視多個輸入通道，你可以註冊多個通道使用一個選擇器，然後使用一個單獨的線程來“選擇”通道：這些通道里已經有可以處理的輸入，或者選擇已準備寫入的通道。這種選擇機制，使得一個單獨的線程很容易來管理多個通道。

3 Selectors（選擇器）

NIO有選擇器，而IO沒有。

選擇器用於使用單個線程處理多個通道。因此，它需要較少的線程來處理這些通道。
線程之間的切換對於操作系統來說是昂貴的。因此，爲了提高系統效率選擇器是有用的。
既可以從通道中讀取數據，又可以寫數據到通道。但流的讀寫通常是單向的。
通道可以異步地讀寫。
通道中的數據總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入

三讀數據和寫數據方式

通常來說NIO中的所有IO都是從 Channel（通道） 開始的。

**從通道進行數據讀取：**創建一個緩衝區，然後請求通道讀取數據。

**從通道進行數據寫入：**創建一個緩衝區，填充數據，並要求通道寫入數據。

基本上，所有的 IO 在NIO 中都從一個Channel 開始。Channel 有點象流。數據可以從Channel讀到Buffer中，也可以從Buffer 寫到Channel中，數據讀取和寫入操作圖示：

四 NIO核心組件簡單介紹

NIO包含下面幾個核心的組件：

Channels
Buffers
Selectors

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

通道（Channel）： 負責連接。
緩衝區（Buffer）： 負責數據的存取
**選擇器（Selector）：**是 SelectableChannle 對象的多路複用器， Selector 可以同時監控多個 SelectableChannel 的 IO 狀況，也就是說，利用 Selector 可使一個單獨的線程管理多個 Channel。 Selector 是非阻塞 IO 的核心。選擇器主要根據註冊的通道的SelectionKey來監聽。

讀 : SelectionKey.OP_READ （1）
寫 : SelectionKey.OP_WRITE （4）
連接 : SelectionKey.OP_CONNECT （8）
接收 : SelectionKey.OP_ACCEPT （16）

Channels(通道)

在Java NIO中，主要使用的通道如下（涵蓋了UDP 和 TCP 網絡IO，以及文件IO）：

FileChannel 從文件中讀寫數據
DatagramChannel 能通過UDP讀寫網絡中的數據。
SocketChannel 能通過TCP讀寫網絡中的數據。
ServerSocketChannel 可以監聽新進來的TCP連接，像Web服務器那樣。對每一個新進來的連接都會創建一個SocketChannel。

**FileChannel **

基本的 FileChannel 示例：

    private void read() throws IOException {
        /**
         * 通過RandomAccessFile開啓FileChannel
         */
        File file = new File(this.getClass().getResource("/").getPath() +"/data/nio-data.txt");
        if(!file.exists()){
            return;
        }
        RandomAccessFile aFile = new RandomAccessFile(file, "rw");
        FileChannel inChannel = aFile.getChannel();
        ByteBuffer buf = ByteBuffer.allocate(1024*1024);
        /**
         * 使用FileChannel讀取數據
         */
        int bytesRead = inChannel.read(buf);
        while (bytesRead != -1) {
            System.out.println("Read " + bytesRead);
            //  Flip()函數將一個能夠繼續添加數據元素的填充狀態的緩衝區翻轉成一個準備讀出元素的釋放狀態。
            buf.flip();
            while(buf.hasRemaining()){
                // 布爾函數會在釋放緩衝區時告訴您是否已經達到緩衝區的上界。以下是一種將數據元素從緩衝區釋放到一個數組的方法
                // remaining()函數將告知您從當前位置到上界還剩餘的元素數目
                //System.out.print((char)buf.get());
                //顯示亂碼，採用默認的編碼方式（UTF-16BE）將ByteBuffer轉換成CharBuffer
                System.out.println(buf.asCharBuffer());
                buf.rewind();//準備重讀
                //當前系統默認編碼方式
                String encoding = System.getProperty("file.encoding");
                //下面我們使用系統默認的編碼方式（GBK）將ByteBuffer轉換成CharBuffer
                System.out.println("Decoded using " + encoding + ": " + Charset.forName(encoding).decode(buf));//顯示正常，因爲寫入與讀出時採用相同編碼方式
            }
            buf.clear();
            bytesRead = inChannel.read(buf);
        }
        /**
         * 關閉FileChannel
         */
        inChannel.close();
        aFile.close();
    }
    private void write() throws IOException {
        String newData = "New String to write to file...";

        RandomAccessFile rdf = new RandomAccessFile(this.getClass().getResource("/").getPath() +"/data/niotest.txt","rw");
        //利用channel中的FileChannel來實現文件的讀取
        FileChannel channel=  rdf.getChannel();
        ByteBuffer buf = ByteBuffer.allocate(48);
        buf.clear();
        buf.put(newData.getBytes());

        buf.flip();

        while(buf.hasRemaining()) {
            channel.write(buf);
        }  
    }

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：

打開一個SocketChannel並連接到互聯網上的某臺服務器。
一個新連接到達ServerSocketChannel時，會創建一個SocketChannel。

SocketChannel並連接到互聯網上的某臺服務器

SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8000));

新連接到達ServerSocketChannel時，會創建一個SocketChannel

 Selector selector = Selector.open();
 ServerSocketChannel  serverSocketChannel = ServerSocketChannel.open();
 serverSocketChannel.bind(new InetSocketAddress(8000));
 serverSocketChannel.configureBlocking(false);
 serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
SocketChannel socketChannel = serverSocketChannel.accept()

DEMO示例：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("localhost", 80));
while(!socketChannel.finishConnect()){
	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()) {
	    socketChannel.write(buf);
	}
}

ServerSocketChannel
Java NIO中的 ServerSocketChannel 是一個可以監聽新進來的TCP連接的通道, 就像標準IO中的ServerSocket一樣。

DEMO示例：

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 channel = DatagramChannel.open();
channel.socket().bind(new InetSocketAddress(9999));

Buffers(緩衝區)

在Java NIO中使用的核心緩衝區如下（覆蓋了通過I/O發送的基本數據類型：byte, char、short, int, long, float, double ，long）：

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
FloatBuffer
DoubleBuffer
LongBuffer
MappedByteBuffer

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

寫入數據到Buffer

調用flip()方法

從Buffer中讀取數據

調用clear()方法或者compact()方法

MappedByteBuffer 有些特別，java處理大文件，一般用BufferedReader,BufferedInputStream這類帶緩衝的Io類，不過如果文件超大的話，更快的方式是採用MappedByteBuffer。 MappedByteBuffer是java nio引入的文件內存映射方案，讀寫性能極高。NIO最主要的就是實現了對異步操作的支持。其中一種通過把一個套接字通道(SocketChannel)註冊到一個選擇器(Selector)中,不時調用後者的選擇(select)方法就能返回滿足的選擇鍵(SelectionKey),鍵中包含了SOCKET事件信息。這就是select模型。

SocketChannel的讀寫是通過一個類叫ByteBuffer(java.nio.ByteBuffer)來操作的.這個類本身的設計是不錯的,比直接操作byte[]方便多了. ByteBuffer有兩種模式:直接/間接.間接模式最典型(也只有這麼一種)的就是HeapByteBuffer,即操作堆內存 (byte[]).但是內存畢竟有限,如果我要發送一個1G的文件怎麼辦?不可能真的去分配1G的內存.這時就必須使用"直接"模式,即 MappedByteBuffer,文件映射.

先中斷一下,

談談操作系統的內存管理.一般操作系統的內存分兩部分:物理內存;虛擬內存.虛擬內存一般使用的是頁面映像文件,即硬盤中的某個(某些)特殊的文件.操作系統負責頁面文件內容的讀寫,這個過程叫"頁面中斷/切換". MappedByteBuffer也是類似的,你可以把整個文件(不管文件有多大)看成是一個ByteBuffer.MappedByteBuffer 只是一種特殊的 ByteBuffer ，即是ByteBuffer的子類。 MappedByteBuffer 將文件直接映射到內存（這裏的內存指的是虛擬內存，並不是物理內存）。通常，可以映射整個文件，如果文件比較大的話可以分段進行映射，只要指定文件的那個部分就可以。

內存映像文件三種方式：
FileChannel提供了map方法來把文件影射爲內存映像文件： MappedByteBuffer map(int mode,long position,long size); 可以把文件的從position開始的size大小的區域映射爲內存映像文件，mode指出了可訪問該內存映像文件的方式：READ_ONLY,READ_WRITE,PRIVATE.

READ_ONLY,（只讀）：試圖修改得到的緩衝區將導致拋出 ReadOnlyBufferException.(MapMode.READ_ONLY)
READ_WRITE（讀/寫）：對得到的緩衝區的更改最終將傳播到文件；該更改對映射到同一文件的其他程序不一定是可見的。 (MapMode.READ_WRITE)
PRIVATE（專用）：對得到的緩衝區的更改不會傳播到文件，並且該更改對映射到同一文件的其他程序也不是可見的；相反，會創建緩衝區已修改部分的專用副本。 (MapMode.PRIVATE)

三個方法：
a. fore();緩衝區是READ_WRITE模式下，此方法對緩衝區內容的修改強行寫入文件
b. load()將緩衝區的內容載入內存，並返回該緩衝區的引用
c. isLoaded()如果緩衝區的內容在物理內存中，則返回真，否則返回假

三個特性：
調用信道的map()方法後，即可將文件的某一部分或全部映射到內存中，映射內存緩衝區是個直接緩衝區，繼承自ByteBuffer,但相對於ByteBuffer,它有更多的優點：
a. 讀取快
b. 寫入快
c. 隨時隨地寫入

 private void copyFile(File sourceFile, File targetFile){
        FileChannel in = null, out = null;
        try {
            in = new FileInputStream(sourceFile).getChannel();
            out = new FileOutputStream(targetFile).getChannel();
            long size = in.size();
            MappedByteBuffer buf = in.map(FileChannel.MapMode.READ_ONLY, 0, size);
            out.write(buf);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                in.close();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

當向buffer寫入數據時，buffer會記錄下寫了多少數據。一旦要讀取數據，需要通過flip()方法將Buffer從寫模式切換到讀模式。在讀模式下，可以讀取之前寫入到buffer的所有數據。

一旦讀完了所有的數據，就需要清空緩衝區，讓它可以再次被寫入。有兩種方式能清空緩衝區：調用clear()或compact()方法。clear()方法會清空整個緩衝區。compact()方法只會清除已經讀過的數據。任何未讀的數據都被移到緩衝區的起始處，新寫入的數據將放到緩衝區未讀數據的後面。

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）

通道(Channel)之間的數據傳輸
在Java NIO中，如果兩個通道中有一個是FileChannel，那你可以直接將數據從一個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被填滿。

給Buffer分配緩衝區容量
要想獲得一個Buffer對象首先要進行分配。每一個Buffer類都有一個allocate方法。下面是一個分配48字節capacity的ByteBuffer的例子。

ByteBuffer buf = ByteBuffer.allocate(48);

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

CharBuffer buf = CharBuffer.allocate(1024);

向Buffer中寫數據
寫數據到Buffer有兩種方式：

使用Channel的read方法寫到Buffer。
通過Buffer的put()方法寫到Buffer裏。

從Channel寫到Buffer的例子

int bytesRead = inChannel.read(buf);

OR 通過put方法寫Buffer的例子：

ByteBuffer b = buf.put((byte)12);

put方法有很多重載方法，允許你以不同的方式把數據寫入到Buffer中。例如，寫到一個指定的位置，或者把一個字節數組寫入到Buffer。

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

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

從Buffer中讀取數據
從Buffer中讀取數據有兩種方式：

使用Buffer讀取數據到Channel。
使用get()方法從Buffer中讀取數據。
從Buffer讀取數據到Channel的例子：

int bytesWritten = inChannel.write(buf);

使用get()方法從Buffer中讀取數據的例子

byte aByte = buf.get();

get方法有很多重載方法，允許你以不同的方式從Buffer中讀取數據。例如，從指定position讀取，或者從Buffer中讀取數據到字節數組。

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();
buffer.reset();

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的元素個數比另一個少)。

Selector(選擇器)

Java NIO提供了“選擇器”的概念。這是一個可以用於監視多個通道的對象，如數據到達，連接打開等，並能夠知曉通道是否爲諸如讀寫事件做好準備的組件。這樣，一個單獨的線程可以管理多個channel，從而管理多個網絡連接。因此，單線程可以監視多個通道中的數據。

如果應用程序有多個通道(連接)打開，但每個連接的流量都很低，則可考慮使用它。例如：在聊天服務器中。

爲什麼使用Selector?
使用單個線程來處理多個Channels時，我們可以只用一個線程處理所有的Channels（通道）。對於操作系統來說，線程之間上下文切換的開銷很大，而且每個線程都要佔用系統的一些資源（如內存）。所有，使用的線程越少越好。

但是，需要記住，現代的操作系統和CPU在多任務方面表現的越來越好，所以多線程的開銷隨着時間的推移，變得越來越小了。實際上，如果一個CPU有多個內核，不使用多任務可能是在浪費CPU能力。不管怎麼說，在這裏，只要知道使用Selector能夠處理多個通道就足夠了。

下面是單線程使用一個Selector處理3個channel的示例圖：

線程使用選擇器來處理3個通道

要使用Selector的話，我們必須把Channel註冊到Selector上，然後就可以調用Selector的select()方法。這個方法會進入阻塞，直到有一個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不能切換到非阻塞模式。而SocketChannel都可以。

注意register()方法的第二個參數。是表示在通過Selector監聽Channel時，你要監聽那種類型的事件。這四種事件分別爲：

SelectionKey.OP_CONNECT
SelectionKey.OP_ACCEPT
SelectionKey.OP_READ
SelectionKey.OP_WRITE

SelectionKey

如同上面，我們還可以來通過selectionKey檢測channel中什麼事件或操作已經就緒。但是，也可以使用以下四個方法，它們都會返回一個布爾類型：

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

Channel和Selector 也可以通過selectionKey 獲得

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

我們還可以將一個對象或者更多信息附着到SelectionKey上，

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

還可以在用register()方法向Selector註冊Channel的時候附加對象。如:

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

通過Selector選擇通道
一旦向Selector註冊了一或多個通道，就可以調用幾個重載的select()方法。這些方法返回你所感興趣的事件（如連接、接受、讀或寫）已經準備就緒的那些通道。select()方法會返回已經就緒的那些通道。

下面是select()方法：

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()方法訪問這些對象。

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

SocketChannel channel = SocketChannel.open();
        Selector selector = Selector.open();
        channel.configureBlocking(false);
        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 = (SelectionKey) 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實例無效。通道本身並不會關閉。

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如何影響應用程序的設計

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

對NIO或IO類的API調用。
數據處理。
用來處理數據的線程數。

API調用
當然，使用NIO的API調用時看起來與使用IO時有所不同，但這並不意外，因爲並不是僅從一個InputStream逐字節讀取，而是數據必須先讀入緩衝區再處理。

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

在IO設計中，我們從InputStream或 Reader逐字節讀取數據。假設你正在處理一基於行的文本數據流，例如：

Name: Anna
Age: 25
Email: anna@mailserver.com
Phone: 1234567890

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

String path = this.getClass().getResource("/").getPath();
InputStream input =  new FileInputStream(path + "/data/data.txt");
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服務器設計- 一個連接通過一個線程處理.)***

java NIO 編程簡介

一 NIO簡介

二 NIO的特性/NIO與IO區別

1 Channels and Buffers（通道和緩衝區）

2 Non-blocking IO（非阻塞IO）

3 Selectors（選擇器）

三讀數據和寫數據方式

四 NIO核心組件簡單介紹

Channels(通道)

Buffers(緩衝區)

Selector(選擇器)

Pipe(管道)

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

使用neovim打造go ide(支持代碼跳轉, 代碼補全, 實時語法檢查)

挑戰程序設計競賽 2.3章習題 poj 3046 Ant Counting

Shell/Python中的用戶名獲取

設計模式-三種工廠模式簡介

java多線程之Future模式應用

Docker 安裝方法

設計模式-策略模式簡介

設計模式-單例模式簡介

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

java NIO 編程 簡介

一 NIO簡介

二 NIO的特性/NIO與IO區別

1 Channels and Buffers（通道和緩衝區）

2 Non-blocking IO（非阻塞IO）

3 Selectors（選擇器）

三 讀數據和寫數據方式

四 NIO核心組件簡單介紹

Channels(通道)

Buffers(緩衝區)

Selector(選擇器)

Pipe(管道)

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

java NIO 編程簡介

三讀數據和寫數據方式