摘要：緩沖區(qū)一個(gè)對象是固定數(shù)量的數(shù)據(jù)的容器。緩沖區(qū)的工作與通道緊密聯(lián)系。對于操作而言，從通道讀取的數(shù)據(jù)會(huì)按順序被散布稱為到多個(gè)緩沖區(qū)，將每個(gè)緩沖區(qū)填滿直至通道中的數(shù)據(jù)或者緩沖區(qū)的最大空間被消耗完。文件通道總是阻塞式的，因此不能被置于非阻塞模式。

從JDK1.4開始，java中提供一個(gè)種叫NIO(Non-Blocking IO)的IO處理機(jī)制。與以往的標(biāo)準(zhǔn)IO機(jī)制(BIO,Blocking IO)不同的是，新的機(jī)制把重點(diǎn)放在了如何縮短抽象與現(xiàn)實(shí)之間的距離上面。NIO中提出了一種新的抽象，NIO 彌補(bǔ)了原來的BIO的不足，它在標(biāo)準(zhǔn) Java 代碼中提供了高速的、面向塊的I/O。

NIO的包括三個(gè)核心概念:緩沖區(qū)(Buffer)、通道(Channel)、選擇器(Selector)。思維導(dǎo)圖如下：

BIO與NIO之間的共同點(diǎn)是他們都是同步的。而非異步的。

BIO是阻塞的(當(dāng)前線程必須等待感興趣的事情發(fā)生), NIO是非柱塞的(事件選擇，感興趣的事情發(fā)生可以通知線程，而不必一直在哪等待);

BIO是面向流式的IO抽象(一次一個(gè)字節(jié)地處理數(shù)據(jù)), NIO是面向塊的IO抽象(每一個(gè)操作都在一步中產(chǎn)生或者消費(fèi)一個(gè)數(shù)據(jù)塊(Buffer));

BIO的服務(wù)器實(shí)現(xiàn)模式為一個(gè)連接一個(gè)線程，NIO服務(wù)器實(shí)現(xiàn)模式為一個(gè)請求一個(gè)線程;

緩沖區(qū)，以及緩沖區(qū)如何工作，是所有 I/O 的基礎(chǔ)。所謂“輸入/輸出”講的無非就是把數(shù)據(jù)移進(jìn)或移出緩沖區(qū)。進(jìn)程執(zhí)行 I/O 操作，歸結(jié)起來，也就是向操作系統(tǒng)發(fā)出請求，讓它要么把緩沖區(qū)里的數(shù)據(jù)排干 (寫)，要么用數(shù)據(jù)把緩沖區(qū)填滿(讀)。大致流程如圖：

注意圖中用戶空間和內(nèi)核空間的概念。用戶空間是常規(guī)進(jìn)程所在區(qū)域。JVM就是常規(guī)進(jìn)程，駐守于用戶空間。用戶空間是非特權(quán)區(qū)域(比如，在該區(qū)域執(zhí)行的代碼就不能直接訪問硬件設(shè)備)。內(nèi)核空間是操作系統(tǒng)所在區(qū)域。內(nèi)核代碼有特別的權(quán)力。

緩沖區(qū)操作發(fā)散/匯聚,許多操作系統(tǒng)能把組裝/分解過程進(jìn)行得更加高效。

這樣用戶進(jìn)程就不必多次執(zhí)行系統(tǒng)調(diào)用(那樣做可能代價(jià)不菲)，內(nèi)核也可以優(yōu)化數(shù)據(jù)的處理 過程，因?yàn)樗颜莆沾齻鬏敂?shù)據(jù)的全部信息。

所有現(xiàn)代操作系統(tǒng)都使用虛擬內(nèi)存。虛擬內(nèi)存意為程序中使用虛擬地址取代物理(硬件RAM)內(nèi)存地址。這樣做好處頗多:

一個(gè)以上的虛擬地址可指向同一個(gè)物理內(nèi)存地址;

虛擬內(nèi)存空間可大于實(shí)際可用的硬件內(nèi)存。

設(shè)備控制器不能通過 DMA 直接存儲(chǔ)到用戶空間，但通過利用上面 到的第一 項(xiàng)，則可以達(dá)到相同效果。把內(nèi)核空間地址與用戶空間的虛擬地址映射到同一個(gè)物理地址，這樣， DMA 硬件(只能訪問物理內(nèi)存地址)就可以填充對內(nèi)核與用戶空間進(jìn)程同時(shí)可見的緩沖區(qū)。

文件I/O屬文件系統(tǒng)范疇，文件系統(tǒng)與磁盤迥然不同。磁盤把數(shù)據(jù)存在扇區(qū)上，通常一個(gè)扇區(qū) 512 字節(jié)。磁盤屬硬件設(shè)備，對何謂文件一無所知，它只是 供了一系列數(shù)據(jù)存取窗口。文件系統(tǒng)把一連串大小一致的數(shù)據(jù)塊組織到一起。有些塊存儲(chǔ)元信息，如空閑塊、目錄、索引等的映射，有些包含文件數(shù)據(jù)。

內(nèi)存映射文件, 為了在內(nèi)核空間 的文件系統(tǒng)頁與用戶空間的內(nèi)存區(qū)之間移動(dòng)數(shù)據(jù)，一次以上的拷貝操作幾乎總是免不了的。

文件鎖定機(jī)制, 允許一個(gè)進(jìn)程阻止其他進(jìn)程存取某文件，或限制其存取方式。通常的用途是控制共享信息的更新方式，或用于事務(wù)隔離。文件鎖有建議使用和強(qiáng)制使用之分。建議型文件鎖會(huì)向 出請求的進(jìn)程 供當(dāng)前鎖定信息，但 操作系統(tǒng)并不要求一定這樣做，而是由相關(guān)進(jìn)程進(jìn)行協(xié)調(diào)并關(guān)注鎖定信息。

并非所有 I/O 都像前幾節(jié)講的是面向塊的，也有流 I/O，其原理模仿了通道。I/O 字節(jié)流必須順序存取，常見的例子有 TTY(控制臺(tái))設(shè)備、打印機(jī)端口和網(wǎng)絡(luò)連接。

流的傳輸一般(也不必然如此)比塊設(shè)備慢，經(jīng)常用于間歇性輸入。

一個(gè)Buffer對象是固定數(shù)量的數(shù)據(jù)的容器。其作用是一個(gè)存儲(chǔ)器，或者分段運(yùn)輸區(qū)，在 這里數(shù)據(jù)可被存儲(chǔ)并在之后用于檢索。緩沖區(qū)的工作與通道緊密聯(lián)系。 Buffer的類層次圖:

Capacity: 容量, 緩沖區(qū)能夠容納的數(shù)據(jù)元素的最大數(shù)量。這一容量在緩沖區(qū)創(chuàng)建時(shí)被設(shè)定，并且永遠(yuǎn)不能被改變;

Limit: 上界, 緩沖區(qū)的第一個(gè)不能被讀或?qū)懙脑亍；蛘哒f，緩沖區(qū)中現(xiàn)存元素的計(jì)數(shù);

Position: 位置, 下一個(gè)要被讀或?qū)懙脑氐乃饕Ｎ恢脮?huì)自動(dòng)由相應(yīng)的get()和put()函數(shù)更新;

Mark: 標(biāo)記, 一個(gè)備忘位置。調(diào)用mark()來設(shè)定mark=postion。調(diào)用reset()設(shè)定position= mark。標(biāo)記在設(shè)定前是未定義的(undefined)。

這四個(gè)屬性之間總是 循以下關(guān)系:0 <= mark <= position <= limit <= capacity。

操作系統(tǒng)的在內(nèi)存區(qū)域中進(jìn)行I/O操作。這些內(nèi)存區(qū)域，就操作系統(tǒng)方面而言，是相連的字節(jié)序列。于是，毫無疑問，只有字節(jié)緩沖區(qū)有資格參與I/O操作。也請回想一下操作系統(tǒng)會(huì)直接存取進(jìn)程——在本例中是JVM進(jìn)程的內(nèi)存空間，以傳輸數(shù)據(jù)。這也意味著I/O操作的目標(biāo)內(nèi)存區(qū)域必須是連續(xù)的字節(jié)序列。在JVM中，字節(jié)數(shù)組可能不會(huì)在內(nèi)存中連續(xù)存儲(chǔ)，或者無用存儲(chǔ)單元 集可能隨時(shí)對其進(jìn)行移動(dòng)。在Java中，數(shù)組是對象，而數(shù)據(jù)存儲(chǔ)在對象中的方式在不同的JVM實(shí)現(xiàn)中都各有不同。

直接緩沖區(qū)被用于與通道和固有 I/O 例程交 互。它們通過使用固有代碼來告知操作系統(tǒng)直接釋放或填充內(nèi)存區(qū)域，對用于通道直接或原始 存取的內(nèi)存區(qū)域中的字節(jié)元素的存儲(chǔ)盡了最大的努力。

通道用于在字節(jié)緩沖區(qū)和位于通道另一邊的實(shí)體(通常是一個(gè)文件或套接字)之間有效地傳輸數(shù)據(jù)。

通道可以形象地比喻為銀行出納窗口使用的動(dòng)導(dǎo)管。您的薪水支票就是您要傳送的信息，載體(Carrier)就好比一個(gè)緩沖區(qū)。您先填充緩沖區(qū)(將您的薪水支票放到載體上)，接著將緩沖“寫”到通道中(將載體進(jìn)導(dǎo)管中)，然后信息負(fù)載就被傳遞到通道另一邊的I/O服務(wù)(銀行出納員)。channel類的繼承關(guān)系如下:

通道提供了一種被稱為Scatter/Gather的重要新功能(有時(shí)也被稱為矢量 I/O)。Scatter/Gather是一個(gè)簡單卻強(qiáng)大的概念，它是指在多個(gè)緩沖區(qū)上實(shí)現(xiàn)一個(gè)簡單的I/O操作。對于一個(gè)write操作而言，數(shù)據(jù)是從幾個(gè)緩沖區(qū)按順序抽取(稱為gather)并沿著通道發(fā)送的。對于 read 操作而言，從通道讀取的數(shù)據(jù)會(huì)按順序被散布(稱為scatter)到多個(gè)緩沖區(qū)，將每個(gè)緩沖區(qū)填滿直至通道中的數(shù)據(jù)或者緩沖區(qū)的最大空間被消耗完。

Scatter的意思是分散，Gather的意思是聚集。我們注意到在上面的類層次結(jié)構(gòu)圖中，除了ByteChannel外，各Channel類還都實(shí)現(xiàn)了兩個(gè)接口，分別是：

ScatteringByteChannel

GatheringByteChannel

public interface ScatteringByteChannel extends ReadableByteChannel
{
   public long read (ByteBuffer [] dsts) throws IOException;
   public long read (ByteBuffer [] dsts, int offset, int length) throws IOException;
}
public interface GatheringByteChannel extends WritableByteChannel
{
   public long write(ByteBuffer[] srcs) throws IOException;
   public long write(ByteBuffer[] srcs, int offset, int length) throws IOException;
}

Channel根據(jù)IO服務(wù)的情況主要分為兩大類，按照《Java NIO》的描述，兩類IO分別是：file I/O 和 stream I/O。前者是針對文件讀寫操作的，而后者多是網(wǎng)絡(luò)通信相關(guān)的和Socket相關(guān)的。Channel分類也基本如此，和前者對應(yīng)的FileChannel，以及與后者對應(yīng)的SocketChannel等類對象。

文件通道總是阻塞式的，因此不能被置于非阻塞模式。

新的socket通道類可以運(yùn)行非阻塞模式并且是可選擇的。全部socket通道類包括DatagramChannel、SocketChannel和ServerSocketChannel
如上面的類圖，所有的socket通道都繼承于AbstractSelectableChannel。

請注意DatagramChannel和SocketChannel 實(shí)現(xiàn)定義讀和寫功能的接口而ServerSocketChannel不實(shí)現(xiàn)。ServerSocketChannel 負(fù)責(zé)監(jiān)聽傳入的連接和創(chuàng)建新的SocketChannel對象，它本身從不傳輸數(shù)據(jù)。

ServerSocketChannel

讓我們從最簡單的ServerSocketChannel來開始對socket通道類的討論。以下是ServerSocketChannel的完整API:

public abstract class ServerSocketChannel extends AbstractSelectableChannel{
    public static ServerSocketChannel open() throws IOException
    public abstract ServerSocket socket();
    public abstract ServerSocket accept() throws IOException;
    public final int validOps()
}

ServerSocketChannel是一個(gè)基于通道的socket監(jiān)聽器。它同我們所熟悉的java.net.ServerSocket執(zhí)行相同的基本任務(wù)，不過它增加了通道語義，因此能夠在非阻塞模式下運(yùn)行。

SocketChannel

SocketChannel，它是使用最多的socket通道類，接口如下：

public abstract class SocketChannel
   extends AbstractSelectableChannel
   implements ByteChannel, ScatteringByteChannel,GatheringByteChannel{
       
   public static SocketChannel open() throws IOException
   public static SocketChannel open (InetSocketAddress remote) throws IOException
   public abstract Socket socket();
   public abstract boolean connect (SocketAddress remote) throws IOException;
   public abstract boolean isConnectionPending();
   public abstract boolean finishConnect() throws IOException;
   public abstract boolean isConnected();
   public final int validOps()
}

socket 和 SocketChannel 類封裝點(diǎn)對點(diǎn)、有序的網(wǎng)絡(luò)連接，類似于我們所熟知并喜愛的 TCP/IP 網(wǎng)絡(luò)連接。SocketChannel 演 戶端發(fā)起同一個(gè)監(jiān)聽服務(wù)器的連接。直到連接成功，它才能 到 數(shù)據(jù)并且只會(huì)從連接到的地址接 。

DatagramChannel

正如SocketChannel對應(yīng)Socket， ServerSocketChannel對應(yīng)ServerSocket，每一個(gè)DatagramChannel對象也有一個(gè)關(guān)聯(lián)的DatagramSocket對象。不過原命名模式在此并未適用: DatagramSocketChannel顯得有點(diǎn)笨拙，因此采用了簡潔的DatagramChannel名稱。

public abstract class DatagramChannel
    extends AbstractSelectableChannel
    implements ByteChannel, ScatteringByteChannel, GatheringByteChannel{

    public static DatagramChannel open( ) throws IOException
    public abstract DatagramSocket socket( );
    public abstract DatagramChannel connect (SocketAddress remote) throws IOException;
    public abstract boolean isConnected( );
    public abstract DatagramChannel disconnect( ) throws IOException;
    public abstract SocketAddress receive (ByteBuffer dst) throws IOException;
    public abstract int send (ByteBuffer src, SocketAddress target)
    public abstract int read (ByteBuffer dst) throws IOException;
    public abstract long read (ByteBuffer [] dsts) throws IOException;
    public abstract long read (ByteBuffer [] dsts, int offset,int length) throws IOException;
    public abstract int write (ByteBuffer src) throws IOException;
    public abstract long write(ByteBuffer[] srcs) throws IOException;
    public abstract long write(ByteBuffer[] srcs, int offset,int length) throws IOException;
}

選擇器提供選擇執(zhí)行已經(jīng)就緒的任務(wù)的能力，這使得多元I/O成為可能。選擇器類管理著一個(gè)被注冊的通道集合的信息和它們的就緒狀態(tài)。通道是和選擇器一起被注冊的，并且使用選擇器來更新通道的就緒狀態(tài)。當(dāng)這么做的時(shí)候，可以選擇將被激發(fā)的線程掛起，直
到有就緒的的通道。

將文件內(nèi)容讀取到一個(gè)字符串中

    public static String readFileToString(String filePath, Charset charset) throws IOException {
        try(FileInputStream in = new FileInputStream(filePath);
            FileChannel channel = in.getChannel()
        ){
            long fileSize = channel.size();
            int bufferSize = 1024;
            if (fileSize < 1024){
                bufferSize = (int)fileSize;
            }
            StringBuilder builder = new StringBuilder((int)(fileSize/2));

            ByteBuffer byteBuffer = ByteBuffer.allocate(bufferSize);
            CharBuffer charBuffer = CharBuffer.allocate(bufferSize/2);
            CharsetDecoder decoder = charset.newDecoder();
            while (channel.read(byteBuffer) != -1) {
                byteBuffer.flip();
                CoderResult rel;
                do{
                    rel = decoder.decode(byteBuffer,charBuffer,false);
                    charBuffer.flip();

                    builder.append(charBuffer.array(),0,charBuffer.limit());
                    charBuffer.clear();
                }while (rel.isOverflow());
                byteBuffer.compact();
            }

            byteBuffer.flip();
            decoder.decode(byteBuffer,charBuffer,true);
            charBuffer.flip();
            builder.append(charBuffer.array(),0,charBuffer.limit());
            charBuffer.clear();

            return builder.toString();
        }
    }

將一串字符串寫入文件中

    public static long writeStringToFile(String filePath, String content, Charset charset) throws IOException {
        long writeSize = 0;
        try(FileOutputStream out = new FileOutputStream(filePath);
            FileChannel channel = out.getChannel()
        ){
            ByteBuffer buffer = ByteBuffer.wrap(content.getBytes(charset));
            while (buffer.hasRemaining()){
                writeSize += channel.write(buffer);
            }
            channel.force(false);
        }
        return writeSize;
    }

只是一個(gè)簡單的ServerSocketChannel

    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress(8888));
//        ssc.configureBlocking(false);
        String hello_string = "hello rudy!";
        ByteBuffer buffer = ByteBuffer.wrap(hello_string.getBytes());
        while (true){
//            System.out.println("wait for connections");
            SocketChannel clientSocket = ssc.accept();
            if (null == clientSocket){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                System.out.println(String.format("incomimg connection from: %s",clientSocket.getRemoteAddress()));
                buffer.rewind();
                clientSocket.write(buffer);
                clientSocket.close();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        SocketChannel channel = SocketChannel.open();
        channel.connect(new InetSocketAddress("localhost",8888));
        ByteBuffer buffer = ByteBuffer.allocate(100);
        CharBuffer charBuffer = CharBuffer.allocate(100);
        CharsetDecoder decoder = Charset.defaultCharset().newDecoder();
        channel.read(buffer);
        buffer.flip();
        decoder.decode(buffer,charBuffer,false);
        charBuffer.flip();
        while (charBuffer.hasRemaining()){
            System.out.println(charBuffer.get());
        }
        channel.close();
    }

較為綜合的例子

    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel channel = ServerSocketChannel.open();
        channel.bind(new InetSocketAddress("localhost",8888));
        channel.configureBlocking(false);

        SelectionKey selectionKey = channel.register(selector,SelectionKey.OP_ACCEPT);

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        CharBuffer charBuffer = CharBuffer.allocate(1024);
        CharsetDecoder decoder = Charset.defaultCharset().newDecoder();

        while (true){
            int readyNum = selector.select();
            if (readyNum <= 0){
                continue;
            }
            Set readyKey = selector.selectedKeys();
            for (SelectionKey tempKey : readyKey){
                if (tempKey.isAcceptable()){
                    ServerSocketChannel tempChannel = (ServerSocketChannel) tempKey.channel();
                    SocketChannel clientChannel = tempChannel.accept();
                    if (null != clientChannel){
                        System.out.println("one connection:" + clientChannel.getRemoteAddress());
                        clientChannel.configureBlocking(false);
                        clientChannel.register(selector,SelectionKey.OP_READ);
                    }
                }

                if(tempKey.isReadable()){
                    SocketChannel tempChannel = (SocketChannel) tempKey.channel();
                    tempChannel.read(buffer);
                    buffer.flip();
                    decoder.decode(buffer,charBuffer,false);
                    charBuffer.flip();
                    String getData = new String(charBuffer.array(),0,charBuffer.limit());
                    System.out.println(tempChannel.getRemoteAddress() + ":" + getData);
                    buffer.clear();
                    charBuffer.clear();
                    tempChannel.write(ByteBuffer.allocate(0));
                    if (getData.equalsIgnoreCase("exit")){
                        tempChannel.close();
                    }
                }

                if (tempKey.isWritable()){
                    SocketChannel tempChannel = (SocketChannel) tempKey.channel();
//                    System.out.println(tempChannel.getRemoteAddress() + ": read");
                }
                readyKey.remove(tempKey);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        DatagramChannel channel = DatagramChannel.open();
        channel.bind(new InetSocketAddress("localhost",8888));
        ByteBuffer buffer = ByteBuffer.allocate(100);
        CharBuffer charBuffer = CharBuffer.allocate(100);
        CharsetDecoder decoder = Charset.defaultCharset().newDecoder();
        while (true){
            buffer.clear();
            charBuffer.clear();
            SocketAddress remoteAddress = channel.receive(buffer);
            buffer.flip();
            decoder.decode(buffer,charBuffer,false);
            charBuffer.flip();
            System.out.println( remoteAddress +":" + new String(charBuffer.array(),0, charBuffer.limit()));
        }

    }

    public static void main(String[] args) throws IOException {
        DatagramChannel channel = DatagramChannel.open();
        String sendData = "哈哈哈 hello rudy!";
        ByteBuffer buffer = ByteBuffer.wrap(sendData.getBytes());
        channel.send(buffer, new  InetSocketAddress("localhost",8888));
        System.out.println("send end!");
    }

關(guān)于異步，同步，阻塞與非阻塞: http://blog.csdn.net/brainkick/article/details/9312407

Java NIO系列教程: http://ifeve.com/java-nio-all/

官網(wǎng)java7 api文檔: http://docs.oracle.com/javase/7/docs/api/

java NIO詳解: http://zalezone.cn/2014/09/17/NIO%E7%B2%BE%E7%B2%B9/