爲什麼需要NIO

標準IO 也就是阻塞I/O（後面統一稱爲I/O），不管是網絡I/O還是磁盤I/O數據寫(outputStream)或者讀(inputStream)都會存在阻塞，一旦出現了阻塞，線程將失去cpu的使用權。在網絡I/O中可以用一個客戶端在服務端就對應一個線程，出現阻塞只會阻塞一個線程而不影響其他的線程。或者使用線程池技術來減少開銷。
但對於連接生存期比較長的協議來說，線程池的大小仍然限制了系統可以同時處理的客戶端數量。例如一個在客戶端之間傳遞消息的即時消息服務器IM。客戶端必須不停地連接服務器以接收即時消息，因此線程池的大小限制了系統可以同時服務的客戶端總數。如果增加線程池的大小，將帶來更多的線程處理開銷，而不能提升系統的性能，因爲在大部分的時間裏客戶端是處於空閒狀態的，並沒有數據傳輸。這就需要大量的線程保持長連接。
還有更加困難的
1 ：程序無法控制哪些線程的優先級更高，最多隻能“建議”，但是操作系統不一定真的就對這個線程的優先級設置的更高去執行
2 ：每個客戶端的請求在服務端可能存在資源競爭，這些客戶端在不同的線程中，這就需要使用鎖機制或者其他互斥機制對依次訪問狀態進行嚴格的同步。否則，由於不同線程上的程序段交錯執行，他們之間會改掉其他線程說做的修改。
這些都說明需要新的一種方式來處理I/O .

NIO的工作機制

概述

標準的IO基於字節流和字符流進行操作的，而NIO是基於通道（Channel）和緩衝區（Buffer）進行操作，數據總是從通道讀取到緩衝區中，或者從緩衝區寫入到通道中。

Java NIO可以讓你非阻塞的使用IO，例如：當線程從通道讀取數據到緩衝區時，線程還是可以進行其他事情。當數據被寫入到緩衝區時，線程可以繼續處理它。從緩衝區寫入通道也類似。

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

Channel(通道)

Channel和IO中的Stream(流)有些類似。但是又有一些不同

既可以從Channel中讀取數據，又可以寫數據到Channel。但流的讀寫通常是單向的。
Channel可以異步地讀寫
Channel中的數據總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入

NIO中的Channel的主要實現有：

FileChannel
DatagramChannel(能通過UDP讀寫網絡中的數據)
SocketChannel(能通過TCP讀寫網絡中的數據)
ServerSocketChannel(可以監聽新進來的TCP連接，像Web服務器那樣。對每一個新進來的連接都會創建一個SocketChannel)
這些通道涵蓋了UDP 和 TCP 網絡IO，以及文件IO

Buffer(緩衝區)

Java NIO中的Buffer用於和NIO通道進行交互。數據是從通道讀入緩衝區，從緩衝區寫入到通道中的。

緩衝區本質上是一塊可以寫入數據，然後可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，並提供了一組方法，用來方便的訪問該塊內存

Buffer的基本用法

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

    1 寫入數據到Buffer
    2 調用flip()方法
    3 從Buffer中讀取數據
    4 調用clear()方法或者compact()方法

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

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

使用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

緩衝區本質上是一塊可以寫入數據，然後可以從中讀取數據的內存。這塊內存被包裝成NIO Buffer對象，並提供了一組方法，用來方便的訪問該塊內存。
理解Buffer的工作原理，需要熟悉它的三個屬性

capacity
position
limit

position和limit的含義取決於Buffer處在讀模式還是寫模式。不管Buffer處在什麼模式，capacity的含義總是一樣的

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）

Java NIO裏關鍵的Buffer實現：

ByteBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer
CharBuffer
這些Buffer覆蓋了你能通過IO發送的基本數據類型：byte, short, int, long, float, double 和 char。
當然還有MappedByteBuffer,HeapByteBuffer,DirectByteBuffer 這裏先不作說明

Buffer的分配

要想獲得一個Buffer對象首先要進行分配。每一個Buffer類都有一個allocate方法。

ByteBuffer buf = ByteBuffer.allocate(48);//分配一個48個字節的ByteBuffer 
CharBuffer buf = CharBuffer.allocate(1024);//分配一個1024個字節的CharBuffer

向Buffer中寫數據兩種方式：

1 從Channel寫到Buffer (inChannel.read(buf); //read into buffer)
2 通過Buffer的put()方法 （buf.put(...)）

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

1 從Buffer讀取到Channel (channel.write(buf)//read from buffer into channel)
2 使用get()方法從Buffer中讀取數據 （buf.get()）

flip()方法

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

換句話說，position現在用於標記讀的位置，limit表示之前寫進了多少個byte、char...現在能讀取多少個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準備好寫數據了，但是不會覆蓋未讀的數據。

rewind()方法

將position設回0，所以你可以重讀Buffer中的所有數據。limit保持不變，仍然表示能從Buffer中讀取多少個元素

mark()與reset()方法

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

equals()與compareTo()方法

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

equals()

equals只是比較Buffer的一部分，不是每一個在它裏面的元素都比較。實際上，它只比較Buffer中的剩餘元素(剩餘元素是從 position到limit之間的元素)

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

有相同的類型（byte、char、int等）。
Buffer中剩餘的byte、char等的個數相等。
Buffer中所有剩餘的byte、char等都相同。

compareTo()

compareTo()方法比較兩個Buffer的剩餘元素

如果滿足下列條件，則認爲一個Buffer“小於”另一個Buffer：

第一個不相等的元素小於另一個Buffer中對應的元素 。
所有元素都相等，但第一個Buffer比另一個先耗盡(第一個Buffer的元素個數比另一個少)。

Selector(選擇器)

Selector允許單線程處理多個 Channel。如果你的應用打開了多個連接（通道），但每個連接的流量都很低，使用Selector就會很方便。例如，在一個聊天服務器中。
這是在一個單線程中使用一個Selector處理3個Channel的圖示：

要使用Selector，得向Selector註冊Channel，然後調用它的select()方法。這個方法會一直阻塞到某個註冊的通道有事件就緒。一旦這個方法返回，線程就可以處理這些事件，事件的例子有如新連接進來，數據接收等。

Selector的創建

Selector selector = Selector.open()

向Selector註冊通道

爲了將Channel和Selector配合使用，必須將channel註冊到selector上。通過SelectableChannel.register()方法來實現，如下：

ServerSocketChannel channel= ServerSocketChannel.open();//開啓一個管道(channel)
Selector selector = Selector.open();//開啓一個選擇器(selector )
channel.configureBlocking(false);//設置channel非阻塞模式
SelectionKey key = channel.register(selector,Selectionkey.OP_READ);//向Selector註冊通道

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

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

Connect
Accept
Read
Write

通道觸發了一個事件意思是該事件已經就緒。所以，某個channel成功連接到另一個服務器稱爲“連接就緒”。一個server socket channel準備好接收新進入的連接稱爲“接收就緒”。一個有數據可讀的通道可以說是“讀就緒”。等待寫數據的通道可以說是“寫就緒”。
這四種事件用SelectionKey的四個常量來表示：

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

如果你對不止一種事件感興趣，那麼可以用“位或”操作符將常量連接起來，如下

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

在上一小節中，當向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 集合通道已經準備就緒的操作的集合。在通過Selector(選擇器)選擇channel(通道)之後，你會首先訪問這個ready set,可以這樣訪問ready集合：

selectionKey.readyOps();

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

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

Channel + Selector

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

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

附加的對象

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

selectionKey.attach(theObject);//附加對象
Object attachedObj = selectionKey.attachment();//獲取附加的對象

還可以在用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()不會阻塞，不管什麼通道就緒都立刻返回（譯者注：此方法執行非阻塞的選擇操作。如果自從前一次選擇操作後，沒有通道變成可選擇的，則此方法直接返回零。）。

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

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

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

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

注意每次迭代末尾的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實例無效。通道本身並不會關閉。

完整的示例

完整的示例，打開一個Selector，註冊一個通道註冊到這個Selector上,然後持續監控這個Selector的四種事件（接受，連接，讀，寫）是否就緒。

        Selector selector = Selector.open();
        ServerSocketChannel channel = ServerSocketChannel.open();
        channel.configureBlocking(false);//設置爲非阻塞模式
        channel.register(selector, SelectionKey.OP_READ);//註冊監聽事件
        while(true) {
          int readyChannels = selector.select();
          if(readyChannels == 0) {
              continue;
          }
          Set<SelectionKey> selectedKeys = selector.selectedKeys();//獲取所有的key集合
          Iterator<SelectionKey> keysIte = selectedKeys.iterator();
          while(keysIte.hasNext()) {
            SelectionKey key = keysIte.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
            }
            keysIte.remove();
          }
        }

NIO的工作實例

FileChannel

Java NIO中的FileChannel是一個連接到文件的通道。可以通過文件通道讀寫文件。
FileChannel無法設置爲非阻塞模式，它總是運行在阻塞模式下。

    @Test
    public void fileChannel() throws IOException {
        RandomAccessFile aFile = new RandomAccessFile("io.txt", "rw");
        FileChannel fileChannel = aFile.getChannel();//打開FileChannel，還可以通過fileoutputStream，fileinputStream打開一個FileChannel
        ByteBuffer buf = ByteBuffer.allocate(1024);//分配一個Buffer。從FileChannel中讀取的數據將被讀到Buffer中。

        int bytesRead = fileChannel.read(buf);//調用FileChannel.read()方法。該方法將數據從FileChannel讀取到Buffer中。read()方法返回的int值表示了有多少字節被讀到了Buffer中。如果返回-1，表示到了文件末尾
        System.out.println(bytesRead);

        while (bytesRead != -1) {
            buf.flip();
            while (buf.hasRemaining()) {
                System.out.print((char) buf.get());
            }
            buf.compact();
            bytesRead = fileChannel.read(buf);
        }
        aFile.close();
        //注意 buf.flip() 的調用，首先讀取數據到Buffer，然後反轉Buffer,接着再從Buffer中讀取數據
    }

SocketChannel和ServerSocketChannel

標準I/O是阻塞的，NIO中

服務端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class Server1 {

    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);
        int opt = SelectionKey.OP_READ + SelectionKey.OP_WRITE;
        sc.register(key.selector(), opt);//註冊讀寫模式監聽
    }

    public static void handleRead(SelectionKey key) throws IOException {
        SocketChannel sc = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(24);
        int bytesRead = sc.read(buffer);//讀取buff中的內容
        while (bytesRead > 0) {//buff中有內容
            System.out.println("server recv : " + new String(buffer.array()));
            buffer.compact();//清除讀取完畢的數據
            bytesRead = sc.read(buffer);//讀取buff中的內容，如果值不爲-1 說明還有數據進行讀取,否則讀取完畢設置 -1 跳出循環
        }
    }

    public static void handleWrite(SelectionKey key) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(12);
        SocketChannel sc = (SocketChannel) key.channel();
        buffer.put("okok".getBytes());
        buffer.flip();
        while (buffer.hasRemaining()) {
            sc.write(buffer);
        }
        buffer.compact();
    }

    public static void selector() {
        Selector selector = null;
        ServerSocketChannel ssc = null;
        try {
            selector = Selector.open();
            ssc = ServerSocketChannel.open();
            ssc.socket().bind(new InetSocketAddress(8080));
            ssc.configureBlocking(false);
            ssc.register(selector, SelectionKey.OP_ACCEPT);

            while (true) {
                if (selector.select(3000) == 0) {
                    System.out.println("等待連接=====");
                    continue;
                }
                Iterator<SelectionKey> iter = selector.selectedKeys()
                        .iterator();
                while (iter.hasNext()) {
                    SelectionKey key = iter.next();
                    iter.remove();
                    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");
                    }
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (selector != null) {
                    selector.close();
                }
                if (ssc != null) {
                    ssc.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客戶端

package com.jx.spring.jms;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.concurrent.TimeUnit;

public class Client1 implements Runnable{

    private SocketChannel socketChannel;

    public Client1(){
        try {
            socketChannel = SocketChannel.open();//打開一個SocketChannel
            socketChannel.configureBlocking(false);//設置SocketChannel爲非阻塞模式
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));//SocketChannel綁定連接ip與端口
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            if (socketChannel.finishConnect()) {//如果完成連接
                int i = 1;
                while (true) {
                    TimeUnit.SECONDS.sleep(2);
                    doWrite(i);
                    doReader();
                    i++;
                    if(i == 10){
                        break;
                    }
                }
            }
            socketChannel.close();
            System.out.println("client excu end!");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new Thread(new Client1()).start();
    }

    private void doReader() {
        try {
            ByteBuffer buffer = ByteBuffer.allocate(24);//定義一個分配1024字節的byteBuffer
            int bytesRead = socketChannel.read(buffer);
            while(bytesRead > 0){
                System.out.println("client recv : " + new String(buffer.array()));
                buffer.compact();//清除讀取完畢的數據
                bytesRead = socketChannel.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void doWrite(int i) {
        try {
            ByteBuffer buffer = ByteBuffer.allocate(1024);//定義一個分配1024字節的byteBuffer
            buffer.clear();
            buffer.put(String.valueOf(i).getBytes());
            buffer.flip();
            while (buffer.hasRemaining()) {
                System.out.println("client  wirte i : " + i);
                socketChannel.write(buffer);
            }
            buffer.compact();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

總結

IO

面向流
阻塞IO

NIO

面向緩衝
非阻塞IO
選擇器

場景使用

NIO ：

在NIO一個線程可以對應一個selector，而一個selector可以輪詢多個Channel，而每個Channel對應了一個Socket。這樣就達到了一個線程處理多個Socket

當selector調用select()時，會查看是否有客戶端準備好了數據。當沒有數據被準備好時，select()會阻塞。平時都說NIO是非阻塞的，但是如果沒有數據被準備好還是會有阻塞現象。

當有數據被準備好時，調用完select()後，會返回一個SelectionKey，SelectionKey表示在某個selector上的某個Channel的數據已經被準備好了。

只有在數據準備好時，這個Channel纔會被選擇.

如果需要管理同時打開的成千上萬個連接，這些連接每次只是發送少量的數據，例如聊天服務器，實現NIO的服務器可能是一個優勢

標準I/O

如果你有少量的連接使用非常高的帶寬，一次發送大量的數據，也許典型的IO服務器實現可能非常契合

jiuxiao199132

發佈了87 篇原創文章 · 獲贊 3 · 訪問量 2萬+

私信關注

深入I/O學習記錄-02java NIO工作機制