原文地址http://www.importnew.com/19816.html

概述

NIO主要有三個核心部分：Channel（通道），Buffer（緩沖區），Selector（選擇區）。傳統IO基于字節流和字符流進行操作，而NIO基于Channel和Buffer（緩沖區）進行操作，數據總是從通道讀取到緩沖區中，或者從緩沖區寫入到通道中。Selector（選擇區）用于監聽多個通道的事件（比如：連接打開，數據到達）。因此，單個線程可以監聽多個數據通道。

NIO和傳統IO（以下會簡稱IO）之間第一個最大的區別是，IO是面向流的，NIO是面向緩沖區的。Java IO面向流意味著每次從讀取一個或多個字節，直至讀取所有字節，他們沒有被緩存在任何地方。此外，它不能前后移動流中的數據，如果需要前后移動流中讀取的數據，首先需要將它緩存到一個緩沖區。NIO的緩沖導向方法略有不同。數據讀取到一個它會稍后處理的緩沖區，需要時可在緩沖區中前后移動。這就增加了處理過程中的靈活性。但是，還需要檢查是否該緩沖區中包含所有您需要處理的數據。而且，需確保當更多的數據讀入緩沖區時，不要覆蓋緩沖區中尚未處理的數據。

IO的各種流是阻塞的。這意味著，當一個線程調用read()或write()時，該線程被阻塞，知道有一些數據被讀取，或數據完全寫入。該線程在此期間不能再干任何事情了。NIO的非阻塞模式，使一個線程從某通道發送請求讀取數據，但是它僅能得到目前可用的數據，如果目前沒有數據可用時，它就什么都不會獲取，而不是保持線程阻塞，所以直至數據變的可以讀取之前，該線程可以繼續做其他的事情。非阻塞寫也是如此。一個線程請求寫入一些數據到某個通道，但不需要等待它完全寫入，這個線程同時可以去做別的事情。線程通常將非阻塞IO的空閑時間用于在其他通道上執行IO操作，所以一個單獨的線程現在可以管理多個輸入和輸出通道（channel）。

Channel

首先說一下Channel，國內大多翻譯成“通道”。Channel和IO中的Stream（流）是差不多一個等級的。只不過Stream是單向的，譬如：InputStream，OutputStream。而Chaeel是雙向的，既可以用來進行讀操作，又可以用來進行寫操作。

NIO的Channel的主要實現有：

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

這里看名字就可以猜出來：分別可以對應文件IO，UDP和TCP（Server和Client）。后面會演示一個案例，基本上是圍繞這四個類型的Channel進行陳述的。

Buffer

NIO中的關鍵Buffer實現有：ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer，分別對應基本數據類型：byte, char, double, float, int, long, short。當然NIO中還有MapperByteBuffer, HeapByteBuffer, DirectByteBuffer等。這里不進行陳述。

Selector

Selector運行單線程可以處理多個Channel，如果你的應用打開了多個通道，而且每個鏈接的流量都很低，使用Selector就會很方便。例如在一個聊天服務器中，客戶端如果要使用Selector，需要向Server的Selector注冊Channel，然后調用它的select()方法。這個方法會一直阻塞到某個注冊的通道有事件就緒。一旦這個方法返回，線程就可以處理這些事件，事件的例子有如新的連接進來，數據接收等。

FileChannel

看完上面的例子，對于第一次接觸到NIO的同學來說有點云里霧里，只說了一些概念，也沒記住什么，更不要說怎么用了。這里開始通過傳統IO以及更新后的NIO來做對比，以更形象的突出NIO的用法，進而使你對NIO有一點點了解。

傳統IO vs NIO

首先，案例1是采用FileInputStream讀取文件內容的

public static void method2(){
       InputStream in = null;
       try{
           in = new BufferedInputStream(new FileInputStream("src/nomal_io.txt"));
 
           byte [] buf = new byte[1024];
           int bytesRead = in.read(buf);
           while(bytesRead != -1)
           {
               for(int i=0;i<bytesRead;i++)
                   System.out.print((char)buf[i]);
               bytesRead = in.read(buf);
           }
       }catch (IOException e)
       {
           e.printStackTrace();
       }finally{
           try{
               if(in != null){
                   in.close();
               }
           }catch (IOException e){
               e.printStackTrace();
           }
       }
   }

下面這個案例是對應上面的NIO形式實現（這里通過RandomAccessFile進行操作，也可以通過FileInputStream.getChannel（）進行操作）：

public static void method1(){
        RandomAccessFile aFile = null;
        try{
            aFile = new RandomAccessFile("src/nio.txt","rw");
            FileChannel fileChannel = aFile.getChannel();
            ByteBuffer buf = ByteBuffer.allocate(1024);
 
            int bytesRead = fileChannel.read(buf);
            System.out.println(bytesRead);
 
            while(bytesRead != -1)
            {
                buf.flip();
                while(buf.hasRemaining())
                {
                    System.out.print((char)buf.get());
                }
 
                buf.compact();
                bytesRead = fileChannel.read(buf);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            try{
                if(aFile != null){
                    aFile.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }

通過自習對比案例1和案例2，應該能看出來，NIO的實現方式會更復雜。有了這個大概印象后我們進入下一步。

Buffer的使用

從案例2中可以總結出使用Buffer一般遵循下面幾個步驟：

分配空間ByteBuffer buf = ByteBuffer.allocate(1024); 還有一種allocateDirecotr后面再做講解
寫入數據到Buffer int bytesRead = fileChannel.read(buf);
調用flip()方法buf.flip();
從Buffer中讀取數據System.out.print((char)buf.get();)
調用clear()方法或者compact()方法

Buffer顧名思義：緩沖區，實際上是一個容器，一個連續數組。Channel提供從文件、網絡讀取數據的渠道，但是讀寫的數據都必須經過Buffer。如下圖

20160519212332738.jpeg

向Buffer中寫數據的過程：

數據通過Channel寫到BufferfileChannel.read(buf))
通過Buffer的put()方法buf.put(...)

從Buffer中讀取數據的過程：

從Buffer讀取到ChannelChannel.write(buf)
使用get()方法從Buffer中讀取數據buf.get()

可以把Buffer簡單地理解為一組基本數據類型的元素列表，它通過幾個變量來保存這個數據當前的位置狀態: capacity, position, limit, mark:

名稱	說明
capacity	緩沖區數組的總長度
position	下一個要操作的數據元素的位置
limit	緩沖區數組中不可操作的下一個元素的位置：limit <= capacity
mark	用于記錄當前position的前一個位置或者默認是0

20160519212348550.png

如圖：我們通過ByteBuffer.allocate(11)方法創建了一個11個byte的數組的緩沖區，初始狀態如上圖，position的位置為0，capacity和limit默認長度都是數組長度。當我們寫入5個字符時，變化如下圖：

20160519212417971.png

這時我們需要將緩沖區中的5個字節數據寫入到Channel的通信通道，所以我們調用ByteBuffer.flip()方法，變化如下圖所示(position設置為0，并將limit設置成之前的position位置)

20160519212431988.png

這時底層操作系統就可以從緩沖區中正確讀取這5個字節數據并發送出去了。在下一次寫數據之前我們再調用clear()方法，緩沖區的索引位置又回到了初始位置。

clear()方法：position將被設置回0，limit設置成capacity，換句話說，Buffer被清空了，其實Buffer中的數據并未被清空，只是這些標記告訴我們可以從哪里開始往Buffer里寫數據。如果Buffer中有一些未讀的數據，調用clear()方法，數據將“被遺忘”，意味著不再有標記會告訴你哪些數據被讀過，哪些還沒有。如果Buffer中仍有未讀的數據，且后續還需要這些數據，但是此時想要先去寫這些數據，那么使用compact()方法。

compact()方法：將所有未讀取的數據拷貝到Buffer起始處。然后將position設置到最后一個未讀元素的后面。limit屬性依然像clear()方法一樣，設置成capacity?，F在Buffer準備好寫數據了，但是不會覆蓋未讀的數據。

通過調用Buffer.mark()方法，可以標記Buffer的一個特定的position，之后可以通過調用Buffer.reset()方法恢復到這個position。Buffer.rewind()方法將position設回0，所以你可以重讀Buffer中的所有數據。limit保持不變，仍然表示能從Buffer中讀取多少個元素。

SocketChannel

說完了FileChannel和Buffer，應該對Buffer的用法比較了解了，這里使用SocketChannel來繼續探討NIO。NIO的強大功能部分來自于Channel的非阻塞特性，套接字的某些操作可能會無限期的阻塞。例如，對accept()方法的調用可能會因為等待一個客戶端連接而阻塞；對read()方法的調用可能會因為沒有數據可讀而阻塞，知道鏈接的另一端來新的數據?？偟膩碚f，創建/接收連接或讀寫數據等I/O調用，都可能無限期地阻塞等待，直到底層的網絡實現發生了什么。慢速的，有損耗的網絡，或僅僅是簡單的網絡故障都可能導致任意時間的延遲。然而不行的是，在調用一個方法之前無法知道其是否會阻塞。NIO的channel湊想的一個重要特征就是可以通過配置它的阻塞行為，以實現非阻塞式的信道。

channel.configureBlocking(false)

在非阻塞式信道上調用一個方法總是會立即返回。這種調用的返回值指示了所有的操作完成的程度。例如，在一個非阻塞式ServerSocketChannel上調用accept()方法，如果有連接請求來了，則返回客戶端SocketChannel，否則返回null。

這里先舉一個TCP應用案例，客戶端采用NIO實現，而服務端依舊使用IO實現。
客戶端代碼(NIO)

public static void client(){
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        SocketChannel socketChannel = null;
        try
        {
            socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.connect(new InetSocketAddress("10.10.195.115",8080));
 
            if(socketChannel.finishConnect())
            {
                int i=0;
                while(true)
                {
                    TimeUnit.SECONDS.sleep(1);
                    String info = "I'm "+i+++"-th information from client";
                    buffer.clear();
                    buffer.put(info.getBytes());
                    buffer.flip();
                    while(buffer.hasRemaining()){
                        System.out.println(buffer);
                        socketChannel.write(buffer);
                    }
                }
            }
        }
        catch (IOException | InterruptedException e)
        {
            e.printStackTrace();
        }
        finally{
            try{
                if(socketChannel!=null){
                    socketChannel.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }

服務端代碼(IO)

public static void server(){
       ServerSocket serverSocket = null;
       InputStream in = null;
       try
       {
           serverSocket = new ServerSocket(8080);
           int recvMsgSize = 0;
           byte[] recvBuf = new byte[1024];
           while(true){
               Socket clntSocket = serverSocket.accept();
               SocketAddress clientAddress = clntSocket.getRemoteSocketAddress();
               System.out.println("Handling client at "+clientAddress);
               in = clntSocket.getInputStream();
               while((recvMsgSize=in.read(recvBuf))!=-1){
                   byte[] temp = new byte[recvMsgSize];
                   System.arraycopy(recvBuf, 0, temp, 0, recvMsgSize);
                   System.out.println(new String(temp));
               }
           }
       }
       catch (IOException e)
       {
           e.printStackTrace();
       }
       finally{
           try{
               if(serverSocket!=null){
                   serverSocket.close();
               }
               if(in!=null){
                   in.close();
               }
           }catch(IOException e){
               e.printStackTrace();
           }
       }
   }

根據案例分析，總結一下SocketChannel的用法
打開SocketChannel：

socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("10.10.195.115",8080));

關閉：

serverSocket.close();

讀取數據：

String info = "I'm "+i+++"-th information from client";
buffer.clear();
buffer.put(info.getBytes());
buffer.flip();
while(buffer.hasRemaining()){
  System.out.println(buffer);
  socketChannel.write(buffer);
}

注意SocketChannel.write()方法的調用是在一個while循環中的。write()方法無法保證能寫多少字節到SocketChannel。所以，我們重復調用write()直到Buffer沒有要寫的字節為止。
非阻塞模式下，read ()方法在尚未讀取到任何數據時可能就返回了。所以需要關注它的int返回值，它會告訴你讀取了多少字節。

TCP服務端的NIO寫法

到目前為止，所有的案例中都沒有涉及Selector。Selector類可以用于避免使用阻塞式客戶端中很浪費資源的“忙等”方法。例如，考慮一個IM服務器。像QQ或者旺旺這樣的，可能有幾萬甚至幾千萬個客戶端同時連接到了服務器，但在任何時刻都只是非常少量的消息。

需要讀取和分發，這就需要一種方法阻塞等待，直到至少有一個信道可以進行I/O操作，并且指出是哪個信道。NIO的選擇器就是先了這樣的功能。一個Selector實例可以同時檢查一組信道的I/O狀態。用專業術語來說，選擇器就是一個多路開關選擇器，因為一個選擇器能夠管理多個信道上的I/O操作。然而如果用傳統方式來處理這么多客戶端，使用的方法是循環地一個個地去檢查所有客戶端是否有I/O操作，如果當前客戶端有I/O操作，則可能把當前客戶端扔給一個線程池去處理，如果沒有I/O操作則進行下一個輪詢，當所有客戶端都輪詢過了又接著從頭開始輪詢；這種方法是非常笨重而且也非常浪費資源，因為大部分客戶端是沒有I/O操作的，但是我們也必須要去檢查；而selector就不一樣，它在內部可以同時管理多個I/O，當一個信道有I/O操作的時候，他會通知selector，selector就是記住這個信道有I/O操作，并且知道是何種I/O操作，是讀呢？是寫呢？還是接受新的連接；所以如果使用selector，它返回的結果只有兩種結果，一種是0，即在你調用的時刻沒有任何客戶端需要I/O操作，另一種結果是一組需要I/O操作的客戶端，所以使用selector不再需要循環做輪詢檢查，返回的結果就是需要的有I/O操作的客戶端。

要使用selector，需要創建一個selector實例（使用靜態工廠方法open()）并將其注冊register到想要監控的信道上（注意，這要通過channel的方法實現，而不是使用selector的方法）。最后，調用選擇器的select()方法。該方法會阻塞等待，直到有一個或更多的信道準備好了I/O操作或等待超時。select()方法將返回可進行I/O操作的信道數量。現在，在一個單獨的線程中，通過調用select()方法就能檢查多個信道是否準備好進行I/O操作。如果經過一段時間后仍然沒有信道準備好，select()方法就會返回0，并允許程序繼續執行其他任務。

下面將上面的TCP服務端代碼改寫成NIO的方式：

public class ServerConnect
{
    private static final int BUF_SIZE=1024;
    private static final int PORT = 8080;
    private static final int TIMEOUT = 3000;
 
    public static void main(String[] args)
    {
        selector();
    }
 
    public static void handleAccept(SelectionKey key) throws IOException{
        ServerSocketChannel ssChannel = (ServerSocketChannel)key.channel();
        SocketChannel sc = ssChannel.accept();
        sc.configureBlocking(false);
        sc.register(key.selector(), SelectionKey.OP_READ,ByteBuffer.allocateDirect(BUF_SIZE));
    }
 
    public static void handleRead(SelectionKey key) throws IOException{
        SocketChannel sc = (SocketChannel)key.channel();
        ByteBuffer buf = (ByteBuffer)key.attachment();
        long bytesRead = sc.read(buf);
        while(bytesRead>0){
            buf.flip();
            while(buf.hasRemaining()){
                System.out.print((char)buf.get());
            }
            System.out.println();
            buf.clear();
            bytesRead = sc.read(buf);
        }
        if(bytesRead == -1){
            sc.close();
        }
    }
 
    public static void handleWrite(SelectionKey key) throws IOException{
        ByteBuffer buf = (ByteBuffer)key.attachment();
        buf.flip();
        SocketChannel sc = (SocketChannel) key.channel();
        while(buf.hasRemaining()){
            sc.write(buf);
        }
        buf.compact();
    }
 
    public static void selector() {
        Selector selector = null;
        ServerSocketChannel ssc = null;
        try{
            selector = Selector.open();
            ssc= ServerSocketChannel.open();
            ssc.socket().bind(new InetSocketAddress(PORT));
            ssc.configureBlocking(false);
            ssc.register(selector, SelectionKey.OP_ACCEPT);
 
            while(true){
                if(selector.select(TIMEOUT) == 0){
                    System.out.println("==");
                    continue;
                }
                Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                while(iter.hasNext()){
                    SelectionKey key = iter.next();
                    if(key.isAcceptable()){
                        handleAccept(key);
                    }
                    if(key.isReadable()){
                        handleRead(key);
                    }
                    if(key.isWritable() && key.isValid()){
                        handleWrite(key);
                    }
                    if(key.isConnectable()){
                        System.out.println("isConnectable = true");
                    }
                    iter.remove();
                }
            }
 
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            try{
                if(selector!=null){
                    selector.close();
                }
                if(ssc!=null){
                    ssc.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

下面來講解這段代碼

ServerSocketChannel

打開ServerSocketChannel：

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

關閉ServerSocketChannel：

serverSocketChannel.close();

監聽新進來的連接：

while(true){
  SocketChannel socketChannel = serverSocketChannel.accept();
}

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...
  }
}

Selector

Selector的創建：

Selector selector = Selector.open()

為了將Channel和Selector配合使用，必須將Channel注冊到Selector上，通過SelectableChannel.register方法來實現，沿用案例5中的部分代碼：

ssc = ServerSocketChannel.open();
ssc.socket().bind(new InetSocketAddress(PORT));
ssc.configureBlocking(false);
ssc.register(selector, SelectionKey.OP_ACCEPT);

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

注意register()方法的第二個參數。這是一個"interest集合"，意思是在通過Selector監聽Channel時對什么事件感興趣。可以箭筒四種不同類型的事件:

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

通道觸發了一個事件的意思是該事件已經就緒。所以，某個channel成功連接到另一個服務器成為連接就緒。一個ServerSocketChanel準備好接收新進入的鏈接成為接收就緒。一個有數據可讀的通道可以說是讀取就緒。等待寫數據的通道可以說是寫就緒

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

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

SelectionKey

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

interest集合
ready集合
Channel
Selector
附加的對象（可選）

interest集合：就像向Selector注冊通道的部分所說的，interest集合是你所選擇的感興趣的事件集合?？梢酝ㄟ^SelectionKey讀寫interest集合。

ready集合：是通道已經準備就緒的操作的集合。在一次選擇（Selection）之后，你回首先訪問這個ready set。Selection將會在下一個小姐進行解釋?？梢赃@樣訪問ready集合：

int readySet = selectionKey.readyOps();

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

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

從SelectionKey訪問Chennel和Selector的API也比較簡單，如下：

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

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

selectionKey.attch(theObject)
Object attachedObj = selectionKey.attchment();

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

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

通過Selector選擇通道

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

int select()
int select(long timeout)
int selectNow()

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

select()方法返回的int值表示有多少通道已經就緒。解釋下就是，自從上次調用了select()方法之后，有多少個通道變成了就緒狀態。如果調用select()方法，因為會有一個通道變成就緒狀態，返回了1，若再次調用select()方法，如果另一個通道就緒了，它會再次返回1.如果對第一個就緒的channel沒有做任何操作，現在就有兩個就緒的通道，但在每次select()方法調用之前，只有一個通道就緒了。

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

Set selectedKeys = selector.selectedKeys();

當向Selector注冊Channel時，Channel.register()方法會返回一個SelectionKey對象。這個對象代表了注冊到該Selector的通道?？梢酝ㄟ^SelectionKey的selectedKeySet()方法訪問這些對象。

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

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

一個完整的使用Selector和ServerSocketChannel的案例可以參考案例5中的selector()方法。

內存映射文件

Java處理大文件，一般用BufferedReader，BufferedInputStream這類緩沖的IO類，不過如果文件超大的話，更快的方式是采用MappedByteBuffer。

MappedByteBuffer是NIO引入的文件內存映射方案，讀寫性能極高。NIO最主要的就是實現了對異步操作的支持。其中一種通過把一個套接字通道（SocketChannel）注冊到一個選擇器（Selector）中，不時的調用后者的select()方法就能返回滿足的SelectionKey，這個SelectionKey中包含了SOCKET事件信息。這就是select模型。

SocketChannel的讀寫是通過一個類叫ByteBuffer來操作的。這個類本身的設計是不錯的，比直接操作byte[]方便很多。ByteBuffer有兩種模式：直接/間接。間接模式是最經典的（也只有這么一種）就是HeapByteBuffer，即操作堆內存(byte[])。但是內存畢竟有限，如果我要發送一個1G的文件怎么辦？不可能真的去分配1G的內存。這是就必須使用“直接”模式，即MappedByteBuffer文件映射。

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

概念

FileChanel提供了map方法來把文件映射為內存映像文件：MappedByteBuffer map(int mode, long position, long size)；可以把文件從position開始的size大小的區域映射為內存映像文件，mode指出了可訪問該內存映像文件的方式：

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

MappedByteBuffer是ByteBuffer的子類，其擴充了三個方法：

force()：緩沖區是READ_WRITE模式下，此方法對緩沖區內容的修改強行寫入文件；
load()：將緩沖區的內容載入內存，并返回該緩沖區的引用；
isLoaded()：如果緩沖區的內容在物理內存中，則返回真，否則返回假；

案例對比

這里通過采用ByteBuffer和MappedByteBuffer分別讀取大小約為5M的文件“src/1.ppt”來比較兩者之間的區別，method3()是采用MappedByteBuffer讀取的，method4()對應的是ByteBuffer。

public static void method4(){
      RandomAccessFile aFile = null;
      FileChannel fc = null;
      try{
          aFile = new RandomAccessFile("src/1.ppt","rw");
          fc = aFile.getChannel();
 
          long timeBegin = System.currentTimeMillis();
          ByteBuffer buff = ByteBuffer.allocate((int) aFile.length());
          buff.clear();
          fc.read(buff);
          //System.out.println((char)buff.get((int)(aFile.length()/2-1)));
          //System.out.println((char)buff.get((int)(aFile.length()/2)));
          //System.out.println((char)buff.get((int)(aFile.length()/2)+1));
          long timeEnd = System.currentTimeMillis();
          System.out.println("Read time: "+(timeEnd-timeBegin)+"ms");
 
      }catch(IOException e){
          e.printStackTrace();
      }finally{
          try{
              if(aFile!=null){
                  aFile.close();
              }
              if(fc!=null){
                  fc.close();
              }
          }catch(IOException e){
              e.printStackTrace();
          }
      }
  }
 
  public static void method3(){
      RandomAccessFile aFile = null;
      FileChannel fc = null;
      try{
          aFile = new RandomAccessFile("src/1.ppt","rw");
          fc = aFile.getChannel();
          long timeBegin = System.currentTimeMillis();
          MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, aFile.length());
          // System.out.println((char)mbb.get((int)(aFile.length()/2-1)));
          // System.out.println((char)mbb.get((int)(aFile.length()/2)));
          //System.out.println((char)mbb.get((int)(aFile.length()/2)+1));
          long timeEnd = System.currentTimeMillis();
          System.out.println("Read time: "+(timeEnd-timeBegin)+"ms");
      }catch(IOException e){
          e.printStackTrace();
      }finally{
          try{
              if(aFile!=null){
                  aFile.close();
              }
              if(fc!=null){
                  fc.close();
              }
          }catch(IOException e){
              e.printStackTrace();
          }
      }
  }

通過在入口函數main()中運行：

method3();
       System.out.println("=============");
       method4();

輸出結果（運行在普通PC機上）：

Read time: 2ms
=============
Read time: 12ms

通過輸出結果可以看出彼此的差別，一個例子也許是偶然，那么下面把5M大小的文件替換為200M的文件，輸出結果：

Read time: 1ms
=============
Read time: 407ms

可以看到差距拉大。
注：MappedByteBuffer有資源釋放的問題：被MappedByteBuffer打開的文件只有在垃圾收集時才會被關閉，而這個點是不確定的。在Javadoc中這里描述：A mapped byte buffer and the file mapping that it represents remian valid until the buffer itself is garbage-collected。詳細可以翻閱參考資料5和6.

其余功能介紹

看完上面的陳述，相信大家對NIO有了一定的了解，下面主要通過幾個案例，來說明NIO的其余功能，下面代碼量偏多，功能性講述偏少。

Scatter/Gatter

分散（scatter）從Channel中讀取是指在讀操作時將讀取的數據寫入多個buffer中。因此，Channel將從Channel中讀取的數據“分散（scatter）”到多個Buffer中

聚集（gather）寫入Channel是指在寫操作時將多個buffer的數據寫入同一個Channel，因此，Channel將多個Buffer中的數據“聚集（gather）”后發送到Channel。

案例：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.FileChannel;
 
public class ScattingAndGather
{
    public static void main(String args[]){
        gather();
    }
 
    public static void gather()
    {
        ByteBuffer header = ByteBuffer.allocate(10);
        ByteBuffer body = ByteBuffer.allocate(10);
 
        byte [] b1 = {'0', '1'};
        byte [] b2 = {'2', '3'};
        header.put(b1);
        body.put(b2);
 
        ByteBuffer [] buffs = {header, body};
 
        try
        {
            FileOutputStream os = new FileOutputStream("src/scattingAndGather.txt");
            FileChannel channel = os.getChannel();
            channel.write(buffs);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

transferFrom & transferTo

FileChannel的transferFrom()方法可以將數據從源通道傳輸到FileChannel中。

public static void method1(){
        RandomAccessFile fromFile = null;
        RandomAccessFile toFile = null;
        try
        {
            fromFile = new RandomAccessFile("src/fromFile.xml","rw");
            FileChannel fromChannel = fromFile.getChannel();
            toFile = new RandomAccessFile("src/toFile.txt","rw");
            FileChannel toChannel = toFile.getChannel();
 
            long position = 0;
            long count = fromChannel.size();
            System.out.println(count);
            toChannel.transferFrom(fromChannel, position, count);
 
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally{
            try{
                if(fromFile != null){
                    fromFile.close();
                }
                if(toFile != null){
                    toFile.close();
                }
            }
            catch(IOException e){
                e.printStackTrace();
            }
        }
    }

方法的輸入參數position表示從position處開始向目標文件寫入數據，count表示最多傳輸的字節數。如果源通道的剩余空間小于 count 個字節，則所傳輸的字節數要小于請求的字節數。此外要注意，在SoketChannel的實現中，SocketChannel只會傳輸此刻準備好的數據（可能不足count字節）。因此，SocketChannel可能不會將請求的所有數據(count個字節)全部傳輸到FileChannel中。

transferTo()方法將數據從FileChannel傳輸到其他的channel中。

public static void method2()
   {
       RandomAccessFile fromFile = null;
       RandomAccessFile toFile = null;
       try
       {
           fromFile = new RandomAccessFile("src/fromFile.txt","rw");
           FileChannel fromChannel = fromFile.getChannel();
           toFile = new RandomAccessFile("src/toFile.txt","rw");
           FileChannel toChannel = toFile.getChannel();
 
           long position = 0;
           long count = fromChannel.size();
           System.out.println(count);
           fromChannel.transferTo(position, count,toChannel);
 
       }
       catch (IOException e)
       {
           e.printStackTrace();
       }
       finally{
           try{
               if(fromFile != null){
                   fromFile.close();
               }
               if(toFile != null){
                   toFile.close();
               }
           }
           catch(IOException e){
               e.printStackTrace();
           }
       }
   }

上面所說的關于SocketChannel的問題在transferTo()方法中同樣存在。SocketChannel會一直傳輸數據直到目標buffer被填滿。

Pipe

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

public static void method1(){
        Pipe pipe = null;
        ExecutorService exec = Executors.newFixedThreadPool(2);
        try{
            pipe = Pipe.open();
            final Pipe pipeTemp = pipe;
 
            exec.submit(new Callable<Object>(){
                @Override
                public Object call() throws Exception
                {
                    Pipe.SinkChannel sinkChannel = pipeTemp.sink();//向通道中寫數據
                    while(true){
                        TimeUnit.SECONDS.sleep(1);
                        String newData = "Pipe Test At Time "+System.currentTimeMillis();
                        ByteBuffer buf = ByteBuffer.allocate(1024);
                        buf.clear();
                        buf.put(newData.getBytes());
                        buf.flip();
 
                        while(buf.hasRemaining()){
                            System.out.println(buf);
                            sinkChannel.write(buf);
                        }
                    }
                }
            });
 
            exec.submit(new Callable<Object>(){
                @Override
                public Object call() throws Exception
                {
                    Pipe.SourceChannel sourceChannel = pipeTemp.source();//向通道中讀數據
                    while(true){
                        TimeUnit.SECONDS.sleep(1);
                        ByteBuffer buf = ByteBuffer.allocate(1024);
                        buf.clear();
                        int bytesRead = sourceChannel.read(buf);
                        System.out.println("bytesRead="+bytesRead);
                        while(bytesRead >0 ){
                            buf.flip();
                            byte b[] = new byte[bytesRead];
                            int i=0;
                            while(buf.hasRemaining()){
                                b[i]=buf.get();
                                System.out.printf("%X",b[i]);
                                i++;
                            }
                            String s = new String(b);
                            System.out.println("=================||"+s);
                            bytesRead = sourceChannel.read(buf);
                        }
                    }
                }
            });
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            exec.shutdown();
        }
    }

DatagramChannel

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

public static void  reveive(){
       DatagramChannel channel = null;
       try{
           channel = DatagramChannel.open();
           channel.socket().bind(new InetSocketAddress(8888));
           ByteBuffer buf = ByteBuffer.allocate(1024);
           buf.clear();
           channel.receive(buf);
 
           buf.flip();
           while(buf.hasRemaining()){
               System.out.print((char)buf.get());
           }
           System.out.println();
 
       }catch(IOException e){
           e.printStackTrace();
       }finally{
           try{
               if(channel!=null){
                   channel.close();
               }
           }catch(IOException e){
               e.printStackTrace();
           }
       }
   }
 
   public static void send(){
       DatagramChannel channel = null;
       try{
           channel = DatagramChannel.open();
           String info = "I'm the Sender!";
           ByteBuffer buf = ByteBuffer.allocate(1024);
           buf.clear();
           buf.put(info.getBytes());
           buf.flip();
 
           int bytesSent = channel.send(buf, new InetSocketAddress("10.10.195.115",8888));
           System.out.println(bytesSent);
       }catch(IOException e){
           e.printStackTrace();
       }finally{
           try{
               if(channel!=null){
                   channel.close();
               }
           }catch(IOException e){
               e.printStackTrace();
           }
       }
   }

可以通過閱讀參考資料2和3了解更多的NIO細節知識，前人栽樹后人乘涼，這里就不贅述啦。

參考資料

JAVA NIO http://tutorials.jenkov.com/java-nio/nio-vs-io.html
JAVA NIO 系列教程 http://ifeve.com/java-nio-all/
JAVA NIO詳解 http://www.cnblogs.com/phoebus0501/archive/2010/12/05/1897245.html
《深入分析Java Web技術內幕》許令波著
java大文件讀寫操作，java nio 之MappedByteBuffer，高效文件/內存映射 http://langgufu.iteye.com/blog/2107023
java nio 之MappedByteBuffer，高效文件/內存映射 http://www.360doc.com/content/13/0302/18/11314689_268892455.shtml#

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

[NIO]攻破NIO技術壁壘

[NIO]攻破NIO技術壁壘

概述

Channel

Buffer

Selector

FileChannel

傳統IO vs NIO

Buffer的使用

SocketChannel

TCP服務端的NIO寫法

ServerSocketChannel

Selector

SelectionKey

通過Selector選擇通道

內存映射文件

概念

案例對比

其余功能介紹

Scatter/Gatter

transferFrom & transferTo

Pipe

DatagramChannel

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

[NIO]攻破NIO技術壁壘

概述

Channel

Buffer

Selector

FileChannel

傳統IO vs NIO

Buffer的使用

SocketChannel

TCP服務端的NIO寫法

ServerSocketChannel

Selector

SelectionKey

通過Selector選擇通道

內存映射文件

概念

案例對比

其余功能介紹

Scatter/Gatter

transferFrom & transferTo

Pipe

DatagramChannel

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频