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更多強調的是多路復用，即通過一個執行緒（行程），即可以管理多個網路連接（所謂的多路）的通信，

如果你覺得寫的不錯，歡迎轉載和點贊， 轉載時請保留作者署名jilodream/王若伊_恩賜解脫（博客鏈接：http://www.cnblogs.com/jilodream/

標籤：其他

上一篇：論elasticsearch在Windows環境的安裝

下一篇：返回列表