前言

現(xiàn)在使用NIO的場景越來越多睬魂，很多網(wǎng)上的技術(shù)框架或多或少的使用NIO技術(shù)愚墓，譬如Tomcat杠氢，Jetty摘能。學習和掌握NIO技術(shù)已經(jīng)不是一個JAVA攻城獅的加分技能续崖，而是一個必備技能。在前面2篇文章《什么是Zero-Copy?》和《NIO相關(guān)基礎(chǔ)篇》中我們學習了NIO的相關(guān)理論知識团搞，而在本篇中我們一起來學習一下Java NIO的實戰(zhàn)知識严望。全文較長，建議先馬后看（記得關(guān)注不迷路）逻恐。

一像吻、概述

NIO主要有三大核心部分：Channel(通道)峻黍，Buffer(緩沖區(qū)), Selector。傳統(tǒng)IO基于字節(jié)流和字符流進行操作拨匆，而NIO基于Channel和Buffer(緩沖區(qū))進行操作姆涩，數(shù)據(jù)總是從通道讀取到緩沖區(qū)中，或者從緩沖區(qū)寫入到通道中惭每。Selector(選擇區(qū))用于監(jiān)聽多個通道的事件（比如：連接打開阵面，數(shù)據(jù)到達）。因此洪鸭，單個線程可以監(jiān)聽多個數(shù)據(jù)通道样刷。

NIO和傳統(tǒng)IO（一下簡稱IO）之間第一個最大的區(qū)別是，IO是面向流的览爵，NIO是面向緩沖區(qū)的置鼻。 Java IO面向流意味著每次從流中讀一個或多個字節(jié)，直至讀取所有字節(jié)蜓竹，它們沒有被緩存在任何地方箕母。此外，它不能前后移動流中的數(shù)據(jù)俱济。如果需要前后移動從流中讀取的數(shù)據(jù)嘶是，需要先將它緩存到一個緩沖區(qū)。NIO的緩沖導(dǎo)向方法略有不同蛛碌。數(shù)據(jù)讀取到一個它稍后處理的緩沖區(qū)聂喇，需要時可在緩沖區(qū)中前后移動。這就增加了處理過程中的靈活性蔚携。但是希太，還需要檢查是否該緩沖區(qū)中包含所有您需要處理的數(shù)據(jù)。而且酝蜒，需確保當更多的數(shù)據(jù)讀入緩沖區(qū)時誊辉，不要覆蓋緩沖區(qū)里尚未處理的數(shù)據(jù)。

IO的各種流是阻塞的亡脑。這意味著堕澄，當一個線程調(diào)用read() 或 write()時，該線程被阻塞霉咨，直到有一些數(shù)據(jù)被讀取蛙紫，或數(shù)據(jù)完全寫入。該線程在此期間不能再干任何事情了躯护。 NIO的非阻塞模式惊来，使一個線程從某通道發(fā)送請求讀取數(shù)據(jù)，但是它僅能得到目前可用的數(shù)據(jù)棺滞，如果目前沒有數(shù)據(jù)可用時裁蚁，就什么都不會獲取。而不是保持線程阻塞继准，所以直至數(shù)據(jù)變得可以讀取之前枉证，該線程可以繼續(xù)做其他的事情。 非阻塞寫也是如此移必。一個線程請求寫入一些數(shù)據(jù)到某通道室谚，但不需要等待它完全寫入，這個線程同時可以去做別的事情崔泵。 線程通常將非阻塞IO的空閑時間用于在其它通道上執(zhí)行IO操作秒赤，所以一個單獨的線程現(xiàn)在可以管理多個輸入和輸出通道（channel）。

1.1 Channel

首先說一下Channel憎瘸，國內(nèi)大多翻譯成“通道”入篮。Channel和IO中的Stream(流)是差不多一個等級的。只不過Stream是單向的幌甘，譬如：InputStream, OutputStream.而Channel是雙向的潮售，既可以用來進行讀操作，又可以用來進行寫操作锅风。
NIO中的Channel的主要實現(xiàn)有：

• FileChannel

• DatagramChannel

• SocketChannel

• ServerSocketChannel

這里看名字就可以猜出個所以然來：分別可以對應(yīng)文件IO酥诽、UDP和TCP（Server和Client）。下面演示的案例基本上就是圍繞這4個類型的Channel進行陳述的皱埠。

1.2 Buffer

NIO中的關(guān)鍵Buffer實現(xiàn)有：ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer肮帐，分別對應(yīng)基本數(shù)據(jù)類型: byte, char, double, float, int, long, short。當然NIO中還有MappedByteBuffer, HeapByteBuffer, DirectByteBuffer等這里先不進行陳述边器。
當向buffer寫入數(shù)據(jù)時泪姨，buffer會記錄下寫了多少數(shù)據(jù)。一旦要讀取數(shù)據(jù)饰抒，需要通過flip()方法將Buffer從寫模式切換到讀模式肮砾。在讀模式下，可以讀取之前寫入到buffer的所有數(shù)據(jù)袋坑。
使用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ù)的后面骑篙。
下面是一個使用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
緩沖區(qū)本質(zhì)上是一塊可以寫入數(shù)據(jù)，然后可以從中讀取數(shù)據(jù)的內(nèi)存森书。這塊內(nèi)存被包裝成NIO Buffer對象靶端，并提供了一組方法，用來方便的訪問該塊內(nèi)存凛膏。

為了理解Buffer的工作原理杨名，需要熟悉它的三個屬性：
capacity
position
limit
position和limit的含義取決于Buffer處在讀模式還是寫模式。不管Buffer處在什么模式猖毫，capacity的含義總是一樣的台谍。

這里有一個關(guān)于capacity，position和limit在讀寫模式中的說明鄙麦，詳細的解釋在插圖后面典唇。

image.png

position
當你寫數(shù)據(jù)到Buffer中時寒波，position表示當前的位置乘盼。初始的position值為0.當一個byte、long等數(shù)據(jù)寫到Buffer后俄烁， position會向前移動到下一個可插入數(shù)據(jù)的Buffer單元绸栅。position最大可為capacity – 1.

當讀取數(shù)據(jù)時，也是從某個特定位置讀页屠。當將Buffer從寫模式切換到讀模式粹胯，position會被重置為0. 當從Buffer的position處讀取數(shù)據(jù)時，position向前移動到下一個可讀的位置辰企。

limit
在寫模式下风纠，Buffer的limit表示你最多能往Buffer里寫多少數(shù)據(jù)。 寫模式下牢贸，limit等于Buffer的capacity竹观。

當切換Buffer到讀模式時， limit表示你最多能讀到多少數(shù)據(jù)。因此臭增，當切換Buffer到讀模式時懂酱，limit會被設(shè)置成寫模式下的position值。換句話說速址，你能讀到之前寫入的所有數(shù)據(jù)（limit被設(shè)置成已寫數(shù)據(jù)的數(shù)量玩焰，這個值在寫模式下就是position）

1.3 Selecter

Selector運行單線程處理多個Channel由驹，如果你的應(yīng)用打開了多個通道芍锚，但每個連接的流量都很低，使用Selector就會很方便蔓榄。例如在一個聊天服務(wù)器中并炮。要使用Selector, 得向Selector注冊Channel，然后調(diào)用它的select()方法甥郑。這個方法會一直阻塞到某個注冊的通道有事件就緒逃魄。一旦這個方法返回，線程就可以處理這些事件澜搅，事件的例子有如新的連接進來伍俘、數(shù)據(jù)接收等。
通道和緩沖區(qū)的機制勉躺，使得線程無需阻塞地等待IO事件的就緒癌瘾，但是總是要有人來監(jiān)管這些IO事件寡痰。這個工作就交給了selector來完成膝藕，這就是所謂的同步。
Selector允許單線程處理多個 Channel锭魔。如果你的應(yīng)用打開了多個連接（通道）蜕企，但每個連接的流量都很低咬荷，使用Selector就會很方便。
要使用Selector轻掩，得向Selector注冊Channel幸乒，然后調(diào)用它的select()方法。這個方法會一直阻塞到某個注冊的通道有事件就緒唇牧，這就是所說的輪詢罕扎。一旦這個方法返回，線程就可以處理這些事件奋构。

優(yōu)化：
一種優(yōu)化方式是：將Selector進一步分解為Reactor壳影，將不同的感興趣事件分開，每一個Reactor只負責一種感興趣的事件弥臼。這樣做的好處是：1宴咧、分離阻塞級別，減少了輪詢的時間径缅；2掺栅、線程無需遍歷set以找到自己感興趣的事件烙肺，因為得到的set中僅包含自己感興趣的事件。

image.png

NIO和epoll：
epoll是Linux內(nèi)核的IO模型氧卧。我想一定有人想問桃笙，AIO聽起來比NIO更加高大上，為什么不使用AIO沙绝？AIO其實也有應(yīng)用搏明，但是有一個問題就是，Linux是不支持AIO的闪檬，因此基于AIO的程序運行在Linux上的效率相比NIO反而更低星著。而Linux是最主要的服務(wù)器OS，因此相比AIO粗悯，目前NIO的應(yīng)用更加廣泛虚循。

說到這里，可能你已經(jīng)明白了样傍，epoll一定和NIO有著很深的因緣横缔。沒錯，如果仔細研究epoll的技術(shù)內(nèi)幕衫哥，你會發(fā)現(xiàn)它確實和NIO非常相似茎刚，都是基于“通道”和緩沖區(qū)的，也有selector炕檩，只是在epoll中斗蒋，通道實際上是操作系統(tǒng)的“管道”。和NIO不同的是笛质，NIO中泉沾，解放了線程，但是需要由selector阻塞式地輪詢IO事件的就緒妇押；而epoll中跷究，IO事件就緒后，會自動發(fā)送消息敲霍，通知selector：“我已經(jīng)就緒了俊马。”可以認為肩杈，Linux的epoll是一種效率更高的NIO柴我。

Selector的創(chuàng)建
通過調(diào)用Selector.open()方法創(chuàng)建一個Selector，如下：
Selector selector = Selector.open();
向Selector注冊通道
為了將Channel和Selector配合使用扩然，必須將channel注冊到selector上艘儒。通過SelectableChannel.register()方法來實現(xiàn)，如下：

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)聽四種不同類型的事件。

• OP_ACCEPT
• OP_CONNECT
• OP_READ
• OP_WRITE

通道觸發(fā)了一個事件意思是該事件已經(jīng)就緒疾牲。所以植捎，某個channel成功連接到另一個服務(wù)器稱為“連接就緒”衙解。一個server socket channel準備好接收新進入的連接稱為“接收就緒”阳柔。一個有數(shù)據(jù)可讀的通道可以說是“讀就緒”。等待寫數(shù)據(jù)的通道可以說是“寫就緒”蚓峦。
如果你對不止一種事件感興趣舌剂，那么可以用“位或”操作符將常量連接起來，如下：
int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
SelectionKey
在上一小節(jié)中暑椰，當向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鲸阔。Selection將在下一小節(jié)進行解釋偷霉。可以這樣訪問ready集合：
int readySet = selectionKey.readyOps();
可以用像檢測interest集合那樣的方法褐筛，來檢測channel中什么事件或操作已經(jīng)就緒类少。但是，也可以使用以下四個方法渔扎，它們都會返回一個布爾類型：

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

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選擇通道
一旦向Selector注冊了一或多個通道定罢，就可以調(diào)用幾個重載的select()方法。這些方法返回你所感興趣的事件（如連接旁瘫、接受祖凫、讀或?qū)懀┮呀?jīng)準備就緒的那些通道。換句話說酬凳，如果你對“讀就緒”的通道感興趣惠况，select()方法會返回讀事件已經(jīng)就緒的那些通道。
下面是select()方法：
int select():阻塞到至少有一個通道在你注冊的事件上就緒了宁仔。
int select(long timeout):和select()一樣稠屠，除了最長會阻塞timeout毫秒(參數(shù))。
int selectNow():不會阻塞翎苫，不管什么通道就緒都立刻返回（譯者注：此方法執(zhí)行非阻塞的選擇操作权埠。如果自從前一次選擇操作后，沒有通道變成可選擇的煎谍，則此方法直接返回零攘蔽。）。

select()方法返回的int值表示有多少通道已經(jīng)就緒呐粘。亦即满俗，自上次調(diào)用select()方法后有多少通道變成就緒狀態(tài)。如果調(diào)用select()方法作岖，因為有一個通道變成就緒狀態(tài)唆垃，返回了1，若再次調(diào)用select()方法鳍咱，如果另一個通道就緒了降盹，它會再次返回1。如果對第一個就緒的channel沒有做任何操作谤辜，現(xiàn)在就有兩個就緒的通道蓄坏，但在每次select()方法調(diào)用之間，只有一個通道就緒了丑念。
selectedKeys()
一旦調(diào)用了select()方法涡戳，并且返回值表明有一個或更多個通道就緒了，然后可以通過調(diào)用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.remove();
}

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

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

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

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)閉贵扰。

完整的示例
這里有一個完整的示例仇穗，打開一個Selector，注冊一個通道注冊到這個Selector上(通道的初始化過程略去),然后持續(xù)監(jiān)控這個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.remove();
  }
}  

二耘子、FileChannel

看完上面的陳述，對于第一次接觸NIO的同學來說云里霧里球切，只說了一些概念谷誓，也沒記住什么，更別說怎么用了吨凑。這里開始通過傳統(tǒng)IO以及更改后的NIO來做對比捍歪，以更形象的突出NIO的用法户辱，進而使你對NIO有一點點的了解。

2.1 傳統(tǒng)IO vs NIO

首先糙臼，案例1是采用FileInputStream讀取文件內(nèi)容的：

    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();
            }
        }
    }

輸出結(jié)果：（略）
案例是對應(yīng)的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();
            }
        }
    }

輸出結(jié)果：（略）
通過仔細對比案例1和案例2，應(yīng)該能看出個大概变逃，最起碼能發(fā)現(xiàn)NIO的實現(xiàn)方式比叫復(fù)雜焚鹊。有了一個大概的印象可以進入下一步了。

2.2 Buffer的使用

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

• 分配空間（ByteBuffer buf = ByteBuffer.allocate(1024); 還有一種allocateDirector后面再陳述）
• 寫入數(shù)據(jù)到Buffer(int bytesRead = fileChannel.read(buf);)
• 調(diào)用filp()方法（ buf.flip();）
• 從Buffer中讀取數(shù)據(jù)（System.out.print((char)buf.get());）
• 調(diào)用clear()方法或者compact()方法

Buffer顧名思義：緩沖區(qū)韧献，實際上是一個容器末患，一個連續(xù)數(shù)組。Channel提供從文件锤窑、網(wǎng)絡(luò)讀取數(shù)據(jù)的渠道璧针，但是讀寫的數(shù)據(jù)都必須經(jīng)過Buffer。如下圖：

image.png

向Buffer中寫數(shù)據(jù)：

• 從Channel寫到Buffer (fileChannel.read(buf))渊啰，說成是從channel讀數(shù)據(jù)到buffer探橱，更好理解“read”方法，數(shù)據(jù)：channel->buffer
• 通過Buffer的put()方法 （buf.put(…)）

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

• 從Buffer讀取到Channel (channel.write(buf))绘证，說成是從buffer寫數(shù)據(jù)到channel隧膏，更好理解“write”方法，數(shù)據(jù)：buffer->channel
• 使用get()方法從Buffer中讀取數(shù)據(jù) （buf.get()）

例如 有一個服務(wù)器通道 ServerSocketChannel serverChannel嚷那，一個客戶端通道 SocketChannel clientChannel胞枕；服務(wù)器緩沖區(qū)：serverBuffer，客戶端緩沖區(qū)：clientBuffer魏宽。

• 當服務(wù)器想向客戶端發(fā)送數(shù)據(jù)時腐泻，需要調(diào)用：clientChannel.write(serverBuffer)。當客戶端要讀時队询，調(diào)用 clientChannel.read(clientBuffer)
• 當客戶端想向服務(wù)器發(fā)送數(shù)據(jù)時派桩，需要調(diào)用：serverChannel.write(clientBuffer)。當服務(wù)器要讀時蚌斩，調(diào)用 serverChannel.read(serverBuffer)

可以把Buffer簡單地理解為一組基本數(shù)據(jù)類型的元素列表铆惑，它通過幾個變量來保存這個數(shù)據(jù)的當前位置狀態(tài)：capacity, position, limit, mark：

image.png

無圖無真相，舉例：我們通過ByteBuffer.allocate(11)方法創(chuàng)建了一個11個byte的數(shù)組的緩沖區(qū)送膳，初始狀態(tài)如上圖员魏，position的位置為0，capacity和limit默認都是數(shù)組長度肠缨。當我們寫入5個字節(jié)時逆趋，變化如下圖：

image.png

這時我們需要將緩沖區(qū)中的5個字節(jié)數(shù)據(jù)寫入Channel的通信信道，所以我們調(diào)用ByteBuffer.flip()方法晒奕，變化如下圖所示(position設(shè)回0闻书，并將limit設(shè)成之前的position的值)：

image.png

調(diào)用clear()方法：position將被設(shè)回0砰盐，limit設(shè)置成capacity，換句話說坑律，Buffer被清空了岩梳，其實Buffer中的數(shù)據(jù)并未被清除，只是這些標記告訴我們可以從哪里開始往Buffer里寫數(shù)據(jù)晃择。如果Buffer中有一些未讀的數(shù)據(jù)宫屠，調(diào)用clear()方法，數(shù)據(jù)將“被遺忘”洛波，意味著不再有任何標記會告訴你哪些數(shù)據(jù)被讀過，哪些還沒有育瓜。如果Buffer中仍有未讀的數(shù)據(jù)，且后續(xù)還需要這些數(shù)據(jù)见间，但是此時想要先寫些數(shù)據(jù)，那么使用compact()方法犹褒。compact()方法將所有未讀的數(shù)據(jù)拷貝到Buffer起始處抵窒。然后將position設(shè)到最后一個未讀元素正后面。limit屬性依然像clear()方法一樣叠骑，設(shè)置成capacity±罨剩現(xiàn)在Buffer準備好寫數(shù)據(jù)了，但是不會覆蓋未讀的數(shù)據(jù)宙枷。

通過調(diào)用Buffer.mark()方法掉房，可以標記Buffer中的一個特定的position，之后可以通過調(diào)用Buffer.reset()方法恢復(fù)到這個position慰丛。Buffer.rewind()方法將position設(shè)回0卓囚，所以你可以重讀Buffer中的所有數(shù)據(jù)。limit保持不變诅病，仍然表示能從Buffer中讀取多少個元素哪亿。

三、SocketChannel

3.1 不使用selecter

說完了FileChannel和Buffer, 大家應(yīng)該對Buffer的用法比較了解了贤笆，這里使用SocketChannel來繼續(xù)探討NIO蝇棉。NIO的強大功能部分來自于Channel的非阻塞特性，套接字的某些操作可能會無限期地阻塞芥永。例如篡殷，對accept()方法的調(diào)用可能會因為等待一個客戶端連接而阻塞；對read()方法的調(diào)用可能會因為沒有數(shù)據(jù)可讀而阻塞埋涧，直到連接的另一端傳來新的數(shù)據(jù)板辽∑媸荩總的來說，創(chuàng)建/接收連接或讀寫數(shù)據(jù)等I/O調(diào)用戳气，都可能無限期地阻塞等待链患，直到底層的網(wǎng)絡(luò)實現(xiàn)發(fā)生了什么。慢速的瓶您，有損耗的網(wǎng)絡(luò)麻捻，或僅僅是簡單的網(wǎng)絡(luò)故障都可能導(dǎo)致任意時間的延遲。然而不幸的是呀袱，在調(diào)用一個方法之前無法知道其是否阻塞贸毕。NIO的channel抽象的一個重要特征就是可以通過配置它的阻塞行為，以實現(xiàn)非阻塞式的信道夜赵。
channel.configureBlocking(false)
在非阻塞式信道上調(diào)用一個方法總是會立即返回明棍。這種調(diào)用的返回值指示了所請求的操作完成的程度。例如寇僧，在一個非阻塞式ServerSocketChannel上調(diào)用accept()方法摊腋，如果有連接請求來了，則返回客戶端SocketChannel嘁傀，否則返回null兴蒸。

這里先舉一個TCP應(yīng)用案例，客戶端采用NIO實現(xiàn)细办，而服務(wù)端依舊使用BIO實現(xiàn)橙凳。
客戶端代碼（案例3）：

    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();
            }
        }
    }

服務(wù)端代碼（案例4）：

    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.write()方法的調(diào)用是在一個while循環(huán)中的。write()方法無法保證能寫多少字節(jié)到SocketChannel笑撞。所以岛啸，我們重復(fù)調(diào)用write()直到Buffer沒有要寫的字節(jié)為止。
非阻塞模式下,read()方法在尚未讀取到任何數(shù)據(jù)時可能就返回了茴肥。所以需要關(guān)注它的int返回值坚踩，它會告訴你讀取了多少字節(jié)。

3.2 使用selecter

到目前為止瓤狐，所舉的案例中都沒有涉及Selector堕虹。不要急，好東西要慢慢來芬首。Selector類可以用于避免使用阻塞式客戶端中很浪費資源的“忙等”方法。例如逼裆，考慮一個IM服務(wù)器郁稍。像QQ或者旺旺這樣的，可能有幾萬甚至幾千萬個客戶端同時連接到了服務(wù)器胜宇，但在任何時刻都只是非常少量的消息耀怜。

需要讀取和分發(fā)恢着。這就需要一種方法阻塞等待，直到至少有一個信道可以進行I/O操作财破，并指出是哪個信道掰派。NIO的選擇器就實現(xiàn)了這樣的功能。一個Selector實例可以同時檢查一組信道的I/O狀態(tài)左痢。用專業(yè)術(shù)語來說靡羡，選擇器就是一個多路開關(guān)選擇器，因為一個選擇器能夠管理多個信道上的I/O操作俊性。然而如果用傳統(tǒng)的方式來處理這么多客戶端略步，使用的方法是循環(huán)地一個一個地去檢查所有的客戶端是否有I/O操作，如果當前客戶端有I/O操作定页，則可能把當前客戶端扔給一個線程池去處理趟薄，如果沒有I/O操作則進行下一個輪詢，當所有的客戶端都輪詢過了又接著從頭開始輪詢典徊；這種方法是非常笨而且也非常浪費資源杭煎，因為大部分客戶端是沒有I/O操作，我們也要去檢查卒落；而Selector就不一樣了羡铲，它在內(nèi)部可以同時管理多個I/O，當一個信道有I/O操作的時候导绷，他會通知Selector犀勒，Selector就是記住這個信道有I/O操作，并且知道是何種I/O操作妥曲，是讀呢贾费？是寫呢？還是接受新的連接檐盟；所以如果使用Selector褂萧，它返回的結(jié)果只有兩種結(jié)果，一種是0葵萎，即在你調(diào)用的時刻沒有任何客戶端需要I/O操作导犹，另一種結(jié)果是一組需要I/O操作的客戶端，這時你就根本不需要再檢查了羡忘，因為它返回給你的肯定是你想要的谎痢。這樣一種通知的方式比那種主動輪詢的方式要高效得多！

要使用選擇器（Selector）卷雕，需要創(chuàng)建一個Selector實例（使用靜態(tài)工廠方法open()）并將其注冊（register）到想要監(jiān)控的信道上（注意节猿，這要通過channel的方法實現(xiàn)，而不是使用selector的方法）。最后滨嘱，調(diào)用選擇器的select()方法峰鄙。該方法會阻塞等待，直到有一個或更多的信道準備好了I/O操作或等待超時太雨。select()方法將返回可進行I/O操作的信道數(shù)量∫髁瘢現(xiàn)在，在一個單獨的線程中囊扳，通過調(diào)用select()方法就能檢查多個信道是否準備好進行I/O操作吩翻。如果經(jīng)過一段時間后仍然沒有信道準備好，select()方法就會返回0宪拥，并允許程序繼續(xù)執(zhí)行其他任務(wù)仿野。

下面將上面的TCP服務(wù)端代碼改寫成NIO的方式（案例5）：

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();
            }
        }
    }
}

其具體過程參考“1.3 Selecter”

四、她君、內(nèi)存映射文件

JAVA處理大文件脚作，一般用BufferedReader,BufferedInputStream這類帶緩沖的IO類，不過如果文件超大的話缔刹，更快的方式是采用MappedByteBuffer球涛。

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

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

先中斷一下,談?wù)劜僮飨到y(tǒng)的內(nèi)存管理.一般操作系統(tǒng)的內(nèi)存分兩部分:物理內(nèi)存;虛擬內(nèi)存.虛擬內(nèi)存一般使用的是頁面映像文件,即硬盤中的某個(某些)特殊的文件.操作系統(tǒng)負責頁面文件內(nèi)容的讀寫,這個過程叫"頁面中斷/切換". MappedByteBuffer也是類似的,你可以把整個文件(不管文件有多大)看成是一個ByteBuffer.MappedByteBuffer 只是一種特殊的ByteBuffer从祝，即是ByteBuffer的子類。 MappedByteBuffer 將文件直接映射到內(nèi)存（這里的內(nèi)存指的是虛擬內(nèi)存引谜，并不是物理內(nèi)存）牍陌。通常，可以映射整個文件员咽，如果文件比較大的話可以分段進行映射毒涧，只要指定文件的那個部分就可以。
概念
FileChannel提供了map方法來把文件影射為內(nèi)存映像文件： MappedByteBuffer map(int mode,long position,long size); 可以把文件的從position開始的size大小的區(qū)域映射為內(nèi)存映像文件贝室，mode指出了 可訪問該內(nèi)存映像文件的方式：

• READ_ONLY,（只讀）： 試圖修改得到的緩沖區(qū)將導(dǎo)致拋出 ReadOnlyBufferException.(MapMode.READ_ONLY)
• READ_WRITE（讀/寫）： 對得到的緩沖區(qū)的更改最終將傳播到文件契讲；該更改對映射到同一文件的其他程序不一定是可見的。 (MapMode.READ_WRITE)
• PRIVATE（專用）： 對得到的緩沖區(qū)的更改不會傳播到文件滑频，并且該更改對映射到同一文件的其他程序也不是可見的捡偏；相反，會創(chuàng)建緩沖區(qū)已修改部分的專用副本峡迷。 (MapMode.PRIVATE)

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

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

案例對比
這里通過采用ByteBuffer和MappedByteBuffer分別讀取大小約為5M的文件"src/1.ppt"來比較兩者之間的區(qū)別楼雹，method3()是采用MappedByteBuffer讀取的模孩，method4()對應(yīng)的是ByteBuffer。

    public static void main(String[] args){
        method3();
        System.out.println("=============");
        method4();
    }

    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();
            }
        }
    }

輸出結(jié)果（運行在普通PC機上）：

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

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

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

可以看到差距拉大谴供。

注：MappedByteBuffer有資源釋放的問題：被MappedByteBuffer打開的文件只有在垃圾收集時才會被關(guān)閉块茁，而這個點是不確定的

五、其余功能介紹

看完以上陳述桂肌，詳細大家對NIO有了一定的了解数焊，下面主要通過幾個案例，來說明NIO的其余功能崎场，下面代碼量偏多佩耳，功能性講述偏少。

5.1 Scatter/Gatter

分散（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中，這樣你可以方便的處理消息頭和消息體燕酷。

案例：

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();
        }
    }
}

5.2 transferFrom & transferTo

FileChannel的transferFrom()方法可以將數(shù)據(jù)從源通道傳輸?shù)紽ileChannel中向族。

    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();
            }
        }
    }

方法的輸入?yún)?shù)position表示從position處開始向目標文件寫入數(shù)據(jù)，count表示最多傳輸?shù)淖止?jié)數(shù)相赁。如果源通道的剩余空間小于 count 個字節(jié)整慎，則所傳輸?shù)淖止?jié)數(shù)要小于請求的字節(jié)數(shù)。此外要注意酱讶，在SoketChannel的實現(xiàn)中退盯，SocketChannel只會傳輸此刻準備好的數(shù)據(jù)（可能不足count字節(jié)）。因此，SocketChannel可能不會將請求的所有數(shù)據(jù)(count個字節(jié))全部傳輸?shù)紽ileChannel中渊迁。

transferTo()方法將數(shù)據(jù)從FileChannel傳輸?shù)狡渌腸hannel中慰照。

    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();
            }
        }
    }

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

5.3 Pipe

Java NIO 管道是2個線程之間的單向數(shù)據(jù)連接毒租。Pipe有一個source通道和一個sink通道。數(shù)據(jù)會被寫到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();//向通道中寫數(shù)據(jù)
                    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();//向通道中讀數(shù)據(jù)
                    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();
        }
    }

5.4 DatagramChannel

Java NIO中的DatagramChannel是一個能收發(fā)UDP包的通道。因為UDP是無連接的網(wǎng)絡(luò)協(xié)議耕漱，所以不能像其它通道那樣讀取和寫入算色。它發(fā)送和接收的是數(shù)據(jù)包。

    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();
            }
        }
    }

待完善螟够。
參考：
Java NIO系列教程
深入理解Java NIO
Java NIO灾梦？看這一篇就夠了！