一、BIO

1、機制

 採用BIO通訊模型的服務端，通常由一個獨立的Acceptor執行緒負責監聽客戶端的連結，它接收到客戶端的連線請求之後為每個客戶端請求建立一個新的執行緒進行鏈路處理，處理完成之後通過輸出流將響應返回給客戶端，執行緒銷燬，這就是典型的一請求一應答的通訊模型。

2、分析

當客戶端併發訪問量增加後，服務端的執行緒個數和客戶端併發訪問按1:1的正比關係遞增，執行緒膨脹之後，系統的效能會急劇下降，甚至會發生執行緒堆疊溢位、建立失敗，最終發生宕機或將死的慘狀。

當然我們可以在服務端使用執行緒池的方式，來保護我們的系統受到高併發的衝擊，但是即使執行緒池在大畢竟也是有限的，這樣會出現大量的請求等待執行緒池的資源，從而效能、時延、併發量還是會面臨很糟糕的情況。

二、NIO

1、機制

概念組成就不說了，網上很多。

採用nio通訊模型的服務端，通常由一個獨立的執行緒selector(選擇器)來管理一個或多個channel，當channel註冊了selector之後，selector會監聽channel的各種事件，如SelectionKey.OP_ACCEPT-接收事件，當註冊的事件發生後，通過迭代器獲取選中的事件-SelectionKey，如果SelectionKey為請求連線事件，則儲存客戶端的SocketChannel並設定非阻塞，再新增可讀監聽事件，這樣在資料可讀之前，selector可以做一些其他的事情；如果SelectionKey為可讀事件，則可以通過執行緒池用SocketChannel獲取資料，進行接下來的邏輯處理，最後將

2、分析

由於selector可以判斷資料的接收狀態，所以可以節省掉等待io資料的時間，而監聽狀態的時間會很快，可以由單執行緒完成，這樣也避免了執行緒的上下文切換。

三、程式碼

1、服務端

1. public class NIOServer {    
2.     //選擇器    
3.     private Selector selector;    
4.     /**  
5.      * 對該通道做一些初始化的工作  
6.      */    
7.     public void initServer(int port) throws IOException {    
8.         // 獲得ServerSocket通道  
     
9.         ServerSocketChannel serverChannel = ServerSocketChannel.open();    
10.         // 設定通道為非阻塞    
11.         serverChannel.configureBlocking(false);    
12.         // 繫結到port埠    
13.         serverChannel.socket().bind(new InetSocketAddress(port));    
14.         // 獲得選擇器    
15.         this.selector = Selector.open();    
16.         //為該通道註冊SelectionKey.OP_ACCEPT事件   
17.         serverChannel.register(selector, SelectionKey.OP_ACCEPT);    
18.     }    
19.     /**  
20.      * 採用輪詢的方式監聽selector上是否有需要處理的事件，如果有，則進行處理  
21.      */    
22.     @SuppressWarnings("unchecked")    
23.     public void listen() throws IOException {    
24.         // 輪詢訪問selector    
25.         while (true) {    
26.             //當註冊的事件到達時，方法返回；否則,該方法會一直阻塞    
27.             selector.select();    
28.             // 獲得selector中選中的項的迭代器，選中的項為註冊的事件    
29.             Iterator ite = this.selector.selectedKeys().iterator();    
30.             while (ite.hasNext()) {    
31.                 SelectionKey key = (SelectionKey) ite.next();    
32.                 // 刪除已選的key,以防重複處理    
33.                 ite.remove();    
34.                 // 客戶端請求連線事件  
35.                 if (key.isAcceptable()) {  
36.                     ServerSocketChannel server = (ServerSocketChannel) key    
37.                             .channel();    
38.                     // 獲得和客戶端連線的通道    
39.                     SocketChannel channel = server.accept();    
40.                     // 設定成非阻塞    
41.                     channel.configureBlocking(false);    
42.                     //可以給客戶端傳送資訊    
43.                     channel.write(ByteBuffer.wrap(new String("abc").getBytes()));    
44.                     //在和客戶端連線成功之後，為了可以接收到客戶端的資訊，需要給通道設定讀的許可權。    
45.                     channel.register(this.selector, SelectionKey.OP_READ);    
46.                 } else if (key.isReadable()) {   
47.                         // 獲得了可讀的事件   
48.                         read(key);    
49.                 }    
50.             }    
51.         }    
52.     }    
53.     /**  
54.      * 處理邏輯  
55.      */    
56.     public void read(SelectionKey key) throws IOException{    
57.         // 伺服器可讀取訊息:得到事件發生的Socket通道    
58.         SocketChannel channel = (SocketChannel) key.channel();    
59.         // 建立讀取的緩衝區    
60.         ByteBuffer buffer = ByteBuffer.allocate(10);    
61.         channel.read(buffer);    
62.         byte[] data = buffer.array();    
63.         String msg = new String(data).trim();    
64.         System.out.println("服務端收到資訊："+msg);    
65.         ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());    
66.         channel.write(outBuffer);// 將訊息回送給客戶端    
67.     }    
68.     /**  
69.      * 啟動服務端測試   
70.      */    
71.     public static void main(String[] args) throws IOException {    
72.         NIOServer server = new NIOServer();    
73.         server.initServer(8000);    
74.         server.listen();    
75.     }    
76. }   

 2、客戶端

1.  public class NIOClient {    
2.     //選擇器    
3.     private Selector selector;    
4.     /**  
5.      * 對該通道做一些初始化的工作  
6.      */    
7.     public void initClient(String ip,int port) throws IOException {    
8.         // 獲得一個Socket通道    
9.         SocketChannel channel = SocketChannel.open();    
10.         // 設定通道為非阻塞    
11.         channel.configureBlocking(false);    
12.         // 選擇器   
13.         this.selector = Selector.open();    
14.         // 客戶端連線伺服器,其實方法執行並沒有實現連線，需要在listen（）方法中調    
15.         //用channel.finishConnect();才能完成連線    
16.         channel.connect(new InetSocketAddress(ip,port));    
17.         //將通道管理器和該通道繫結，併為該通道註冊SelectionKey.OP_CONNECT事件。    
18.         channel.register(selector, SelectionKey.OP_CONNECT);    
19.     }    
20.     /**  
21.      * 採用輪詢的方式監聽selector上是否有需要處理的事件，如果有，則進行處理  
22.      */    
23.     @SuppressWarnings("unchecked")    
24.     public void listen() throws IOException {    
25.         // 輪詢訪問selector    
26.         while (true) {    
27.             selector.select();    
28.             // 獲得selector中選中的項的迭代器    
29.             Iterator ite = this.selector.selectedKeys().iterator();    
30.             while (ite.hasNext()) {    
31.                 SelectionKey key = (SelectionKey) ite.next();    
32.                 // 刪除已選的key,以防重複處理    
33.                 ite.remove();    
34.                 // 連線事件發生    
35.                 if (key.isConnectable()) {    
36.                     SocketChannel channel = (SocketChannel) key    
37.                             .channel();    
38.                     // 如果正在連線，則完成連線    
39.                     if(channel.isConnectionPending()){    
40.                         channel.finishConnect();    
41.                     }    
42.                     // 設定成非阻塞    
43.                     channel.configureBlocking(false);    
44.                     //在這裡可以給服務端傳送資訊哦    
45.                     channel.write(ByteBuffer.wrap(new String("abc").getBytes()));    
46.                     //在和服務端連線成功之後，為了可以接收到服務端的資訊，需要給通道設定讀的許可權。    
47.                     channel.register(this.selector, SelectionKey.OP_READ);    
48.                     // 獲得了可讀的事件    
49.                 } else if (key.isReadable()) {    
50.                         read(key);    
51.                 }    
52.             }    
53.         }    
54.     }   
55.     /**  
56.      * 處理邏輯  
57.      */    
58.     public void read(SelectionKey key) throws IOException{    
59.         SocketChannel channel = (SocketChannel) key.channel();    
60.         // 建立讀取的緩衝區    
61.         ByteBuffer buffer = ByteBuffer.allocate(10);    
62.         channel.read(buffer);    
63.         byte[] data = buffer.array();    
64.         String msg = new String(data).trim();    
65.         System.out.println("客戶端收到資訊："+msg);     
66.     }    
67.     /**  
68.      * 啟動客戶端測試   
69.      */    
70.     public static void main(String[] args) throws IOException {    
71.         NIOClient client = new NIOClient();    
72.         client.initClient("localhost",8000);    
73.         client.listen();    
74.     }    
75. }