Java網路程式設計----通過實現簡易聊天工具來聊聊NIO

前文我們說過了BIO，今天我們聊聊NIO。
NIO 是什麼？NIO官方解釋它為New lO，由於其特性我們也稱之為,Non-Blocking IO。這是jdk1.4之後新增的一套IO標準。
為什麼要用NIO呢？
我們再簡單回顧下BIO：
阻塞式IO，原理很簡單，其實就是多個端點與伺服器端進行通訊時，每個使用者端有一個自己的socket，他們與伺服器端的serverSocket進行連線，伺服器端為每一個使用者端socket 生成一個對應的socket。
這樣使用者端就可以通過自己的socket進行與伺服器端的讀寫，而伺服器端也可以通過對應的socket與使用者端進行讀寫。
由於這些socket需要一致持有等待接聽和連線，所以只能阻塞式的原地等待。這大大降低了伺服器的效能上限。這就像是一個服務員只能對接自己當前的客人，無法接收多個客人的需求。
那怎麼解決呢？(防盜連線：本文首發自http://www.cnblogs.com/jilodream/ )

我先舉個例子，酒店的廚房只有一個廚師，廚師並不會依次對接每一個客人，滿足客人需求後，再對接下一個客人，而是會收到一份包含當前所有客戶要求的菜品單。
然後開始處理菜品單，同時收集新的需求到新的菜品單中。當菜品單中所有菜品處理完成後，清空舊的菜品單，處理新的菜品單，如此反覆迴圈。他並不會告訴第一個客人才做好了，才接收第二個客人要求的菜品。
我們來看看這個是如何實現的：

1、建立selector----->相當於廚師
2、建立伺服器端socketChannel
3、將伺服器端socketChannel繫結到selector中，同時接收accept事件------->相當於廚師收到的菜品單
4、開始迴圈，處理事件佇列中收到的所有事件------->相當於廚師處理客戶的訴求
5、如果有accept事件，就把accept事件中新連線channel也繫結到selector中，同時接收read事件。
6、處理完所有事件後清空事件佇列中的事件 ------->廚師處理完所有菜品後，清空菜品單(防盜連線：本文首發自http://www.cnblogs.com/jilodream/ )
這裡本質上其實就是繫結事件，監聽請求，處理事件，只是換成批次監聽，和批次處理了。
伺服器端程式碼：

 1 package com.example.demo.learn.tcp;
 2 
 3 import java.io.IOException;
 4 import java.net.InetSocketAddress;
 5 import java.nio.ByteBuffer;
 6 import java.nio.channels.SelectionKey;
 7 import java.nio.channels.Selector;
 8 import java.nio.channels.ServerSocketChannel;
 9 import java.nio.channels.SocketChannel;
10 import java.util.Set;
11 
12 /**
13  * @discription
14  */
15 public class NIOServer {
16     static Object obj;
17 
18     public static void main(String[] args) throws IOException {
19         Selector selector = Selector.open();
20         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
21         serverSocketChannel.socket().bind(new InetSocketAddress(9999));
22         serverSocketChannel.configureBlocking(false);
23         serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
24         while (true) {
25             selector.select();//注意這裡
26             Set<SelectionKey> allKey = selector.selectedKeys();
27             for (SelectionKey selectionKey : allKey) {
28                 if (selectionKey.isAcceptable()) {
29                     ServerSocketChannel serverChannel = (ServerSocketChannel) selectionKey.channel();
30                     if (serverChannel == serverSocketChannel) {
31                         int a = 1;
32                     }
33                     SocketChannel client = serverChannel.accept();
34                     client.configureBlocking(false);
35                     client.register(selector, SelectionKey.OP_READ);
36                     obj = client;
37                 } else if (selectionKey.isReadable()) {
38                     SocketChannel client = (SocketChannel) selectionKey.channel();
39                     if (client == obj) {
40                         int a = 1;
41                     }
42                     ByteBuffer buffer = ByteBuffer.allocate(1024);
43                     client.read(buffer);
44                     buffer.flip();
45                     byte[] bytes = new byte[buffer.remaining()];
46                     buffer.get(bytes);
47                     System.out.println("received msg :" + new String(bytes));
48                     ByteBuffer responseBuffer = ByteBuffer.wrap("Hello , client!".getBytes());
49                     client.write(responseBuffer);
50                 }
51             }
52             allKey.clear();
53         }
54     }
55 }

為了清晰，使用者端程式碼我們仍然採用BIO模式中的使用者端程式碼：

 1 public class TCPClient {
 2     public static void main(String[] args) throws IOException {
 3         Socket clientSocket=new Socket("127.0.0.1",9999);
 4         ChatThread chatThread = new ChatThread(clientSocket);
 5         new Thread(chatThread).start();
 6 
 7     }
 8 }
 9 
10 class ChatThread implements Runnable {
11     private Socket clientSocket;
12 
13     ChatThread(Socket clientSocket) {
14         this.clientSocket = clientSocket;
15     }
16 
17     @Override
18     public void run() {
19         try {
20             OutputStream os = clientSocket.getOutputStream();
21             SayThread sayThread = new SayThread(os);
22             new Thread(sayThread).start();
23 
24             InputStream is = clientSocket.getInputStream();
25             byte[] buffer = new byte[1024];
26             int len = is.read(buffer);
27             while (len > 0) {
28                 String msg = new String(buffer, 0, len);
29                 System.out.println("");
30                 System.out.println("receive server msg :");
31                 System.out.println(msg);
32                 System.out.println("");
33                 len = is.read(buffer);
34             }
35             clientSocket.close();
36 
37         } catch (Exception ex) {
38             //logs
39         }
40 
41     }
42 }
43 
44 class SayThread implements Runnable {
45     private OutputStream os;
46 
47     SayThread(OutputStream outputStream) {
48         this.os = outputStream;
49     }
50 
51     @Override
52     public void run() {
53         try {
54             os.write("client connect success!!!".getBytes());
55             Scanner inputScanner = new Scanner(System.in);
56             while (true) {
57                 String str = inputScanner.nextLine();
58                 os.write(str.getBytes());
59                 os.flush();
60             }
61 
62         } catch (Exception ex) {
63             //logs
64         }
65 
66     }
67 }

先執行伺服器端，然後執行使用者端，我們來看下效果：

如果到這裡你還沒看懂，有一點點迷，那麼你只要記住整個NIO中我們其實只要關注三個核心東西，然後再結合前文是橙色粗體字的程式碼思路來理解下：
Channel：通道，類似於BIO中的Socket，我們可以通過它來進行讀寫；(防盜連線：本文首發自http://www.cnblogs.com/jilodream/ )
Selector：選擇器，我們將Channel和他需要關心的事件繫結起來，當事件響應時，啟用對應的Channel（我們常用到的監聽事件，就是連線accept事件和讀read事件）；
Buffer：快取，我們用來配合Channel完成高效讀寫的物件（這個具體內容比較複雜而且比較多，我後邊會寫文章專門介紹，這裡先不用關心）；

整體的結構圖大概是這個樣子的：

到這裡，我們基本就對NIO有一個大致的瞭解了，那麼NIO的程式碼中完全不存在阻塞等待麼？
答案是還會發生阻塞等待，注意程式碼中的紅色標記（如圖，通過debug，我們也會發現執行緒阻塞到了這裡），當執行緒執行到select方法處時，會進行阻塞等待。

那為什麼NIO的核心元件selector 會使用一個阻塞性方法呢？

這是由於NIO本來指的就是New IO，只是在網路資料處理時，是非阻塞的，不需要單獨存在一個執行緒管理socket等待對方寫入。
而NIO更多強調的是多路複用，即通過一個執行緒（程序），即可以管理多個網路連線（所謂的多路）的通訊。