深入學習Netty（2）——傳統NIO程式設計

JJian發表於2021-07-06
Netty程式設計

前言

　　學習Netty程式設計，避免不了從瞭解Java 的NIO程式設計開始，這樣才能通過比較讓我們對Netty有更深的瞭解，才能知道Netty大大的好處。傳統的NIO程式設計code起來比較麻煩，甚至有遺留Bug，但其中最基本的思想是一致的。

　　參考資料《Netty In Action》、《Netty權威指南》（有需要的小夥伴可以評論或者私信我）

　　博文中所有的程式碼都已上傳到Github，歡迎Star、Fork

 

 

一、NIO 核心元件

　　NIO，有人稱之為New I/O，這是官方叫法。但是由於之前老的I/O類庫是阻塞I/O，所以此時的NIO也可以是非阻塞I/O（Non-block I/O）。

　　與Socket類和ServerSocket類相對應，NIO提供了SocketChannel和ServerSocketChannel不同的套接字通道實現，可以支援阻塞和非阻塞兩種模式。

　　NIO庫是JDK 1.4中引入的，彌補了原來同步阻塞I/O的不足。這是因為提供了高速處理、面向塊的I/O，主要包括：緩衝區Buffer、通道Channel、多路複用器Selector。

1.緩衝區Buffer

　　在NIO庫中，所有的資料都是緩衝區處理的，讀取資料時直接讀取緩衝區；在寫入資料時，寫入到緩衝區。在任何時候訪問NIO中的資料，都是通過緩衝區進行操作。實際上緩衝區是一個陣列，有不同型別的陣列，通常是位元組陣列（ByteBuffer），但它不僅僅是一個陣列，緩衝區提供對資料的結構化訪問以及維護讀寫位置（limit）等資訊。

　　 

2.通道Channel

　　網路資料通過Channel雙向讀取和寫入（全雙工），這點不同於Stream(InputStream/OutputStream或者其子類)一個方向上移動。

　　Channel可以分類兩個大類：用於網路讀寫的SelectableChannel和用於檔案操作的FileChannel。

　　ServerSocketChannel和SocketChannel都是SelectableChannel的子類。

　　

3.多路複用器Selector

　　多路複用器提供選擇已經就緒的任務的能力，具體來說：Selector會不斷地輪詢註冊在其上的Channel，如果某個Channel上面發生讀寫事件，就表明這個Channel處於就緒狀態，會被Selector輪詢出來，通過SelectionKey可以獲取就緒的Channel的集合，進行後續的I/O操作。這樣就意味著只需要一個執行緒負責Selector輪詢，就可以接入成千上萬的客戶端。

　　多路複用器Selector是最核心的元件，在Netty程式設計中也是尤為重要的，但是這裡不具體展開，到時候分析Netty原始碼的時候會具體介紹。

二、NIO服務端

1.服務端序列圖

先放出如下的NIO服務端序列圖，結合序列圖給具體的步驟如下，之後的示例程式碼中也會有詳細註釋

　　

 

第一步：開啟ServerSocketChannel，用於監聽客戶端的連線，是所有客戶端連線的父管道。

第二步：繫結監聽埠，設定連線為非阻塞模式

第三步：建立Reactor執行緒，建立多路複用器並啟動執行緒

第四步：將ServerSocketChannel註冊到Reactor執行緒的多路複用器Selector上，監聽ACCPET事件。

第五步：多路複用器線上程run方法在無線迴圈體內輪詢準備就緒的Key。

第六步：多路複用器監聽到有新的客戶端接入，處理新的接入請求，完成TCP三次握手，建立物理鏈路。

第七步：設定客戶端鏈路為非阻塞模式

第八步：將新接入的客戶端註冊到Reactor執行緒的多路複用器上，監聽讀操作，讀取客戶端傳送的網路訊息。

第九步：非同步讀取客戶端請求訊息到緩衝區

第十步：對ByteBuffer進行編解碼，如果有半包訊息指標reset，繼續讀取後續的報文，將解碼成功的訊息封裝成Task，交給業務執行緒池中，進行業務處理

第十一步：將物件encode成ByteBuffer，呼叫SocketChannel的非同步write介面，將訊息非同步傳送給客戶端。

2.服務端程式碼示例

（1）多路複用服務MultiplexerTimeServer

public class MultiplexerTimeServer implements Runnable {

    private Selector selector;

    private ServerSocketChannel servChannel;

    private volatile boolean stop;

    /**
     * 初始化多路複用器、繫結監聽埠
     *
     * @param port
     */
    public MultiplexerTimeServer(int port) {
        try {
            // 1. 開啟ServerSocketChannel，監聽客戶端連線
            servChannel = ServerSocketChannel.open();
            // 2. 繫結監聽埠，設定連線為非阻塞模式
            servChannel.socket().bind(new InetSocketAddress(port), 1024);
            servChannel.configureBlocking(false);
            // 3. 建立Reactor執行緒，建立多路複用並啟動執行緒
            selector = Selector.open();
            // 4. 將ServerSocketChannel註冊到Reactor執行緒的多路了複用器Selector，監聽ACCEPT事件
            servChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("The time server is start in port : " + port);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    public void stop() {
        this.stop = true;
    }


    @Override
    public void run() {
        while (!stop) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectedKeys.iterator();
                SelectionKey key = null;
                // 迴圈輪詢準備就緒的Key
                while (it.hasNext()) {
                    key = it.next();
                    it.remove();
                    try {
                        // deal with I/O event
                        handleInput(key);
                    } catch (Exception e) {
                        if (key != null) {
                            key.cancel();
                            if (key.channel() != null) {
                                key.channel().close();
                            }
                        }
                    }
                }
            } catch (Throwable t) {
                t.printStackTrace();
            }
        }
        // 多路複用器關閉後，所有註冊在上面的Channel和Pipe等資源都會被自動去註冊並關閉，所以不需要重複釋放資源
        if (selector != null) {
            try {
                selector.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void handleInput(SelectionKey key) throws IOException {
        if (key.isValid()) {
            // 處理新接入的請求訊息
            if (key.isAcceptable()) {
                // a connection was accepted by a ServerSocketChannel
                ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                // 6. 監聽到新的客戶端接入，處理新的接入請求我，完成TCP三次握手-->建立鏈路
                SocketChannel sc = ssc.accept();
                // 7. 設定客戶端鏈路為非阻塞模式
                sc.configureBlocking(false);
                sc.socket().setReuseAddress(true);
                // 8. 將新接入的客戶端連線註冊到Reactor執行緒的多路複用器上，監聽讀操作，讀取客戶端傳送的訊息
                sc.register(selector, SelectionKey.OP_READ);
            }
            if (key.isReadable()) {
                // a channel is ready for reading
                SocketChannel sc = (SocketChannel) key.channel();
                ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                // 9. 非同步讀取客戶端請求訊息到緩衝區
                int readBytes = sc.read(readBuffer);
                if (readBytes > 0) {
                    readBuffer.flip();
                    // 10. 讀取解碼報文
                    byte[] bytes = new byte[readBuffer.remaining()];
                    readBuffer.get(bytes);
                    String body = new String(bytes, "UTF-8");
                    System.out.println("The time server receive order : " + body);
                    String currentTime = "QUERY TIME ORDER"
                            .equalsIgnoreCase(body) ? new java.util.Date(
                            System.currentTimeMillis()).toString()
                            : "BAD ORDER";
                    doWrite(sc, currentTime);
                } else if (readBytes < 0) {
                    // 對端鏈路關閉
                    key.cancel();
                    sc.close();
                } else {
                    // 讀到0位元組，忽略
                }
            }
        }
    }

    private void doWrite(SocketChannel channel, String response)
            throws IOException {
        if (response != null && response.trim().length() > 0) {
            byte[] bytes = response.getBytes();
            ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
            writeBuffer.put(bytes);
            writeBuffer.flip();
            channel.write(writeBuffer);
        }
    }
}

（2）NIO服務TimeServer

public class TimeServer {

    public static void main(String[] args) {
        int port = 8084;
        MultiplexerTimeServer timeServer = new MultiplexerTimeServer(port);
        new Thread(timeServer, "NIO-TimeServer").start();
    }
}

（3）開啟服務端

執行TimeServer：

使用netstat命令檢視是否對8084埠開啟監聽

三、NIO客戶端

1.客戶端序列圖

第一步：開啟SocketChannel，繫結客戶端本地地址（可選，預設系統會隨機會分配一個可用的本地地址）

第二步：設定SocketChannel為非阻塞模式，同時設定客戶端連線的TCP引數

第三步：非同步連線服務端

第四步：判斷是否連線成功，如果連線成功則直接註冊讀狀態位到多路複用中。如果沒有當前沒有連線成功（非同步連線，返回false，說明客戶端已經傳送sync包，服務端沒有返回ack包，物理鏈路還沒建立）

第五步：向Reactor執行緒的多路複用OP_CONNECT狀態位，監聽服務端的TCP ACK應答

第六步：建立Reactor執行緒，建立多路複用器並啟動執行緒。

第七步：多路複用線上程run方法無線迴圈體內輪詢準備就緒的Key

第八步：接收connect事件進行處理

第九步：判斷連線結果，如果連線成功，註冊讀事件到多路複用器，

第十步：註冊讀事件到多路複用器

第十一步：非同步讀客戶端請求訊息到緩衝區

第十二步：對ByteBuffer進行編解碼

第十三步：將POJO物件encode成ByteBuffer，呼叫SocketChannel的非同步write介面，將訊息非同步傳送給客戶端。

2.客戶端示例程式碼

（1）客戶端處理TimeClientHandle

public class TimeClientHandle implements Runnable {

    private String host;
    private int port;
    private Selector selector;
    private SocketChannel socketChannel;
    private volatile boolean stop;

    public TimeClientHandle(String host, int port) {
        this.host = host == null ? "127.0.0.1" : host;
        this.port = port;
        try {
            // 建立多路複用器並開啟
            selector = Selector.open();
            // 1.開啟SocketChannel，
            socketChannel = SocketChannel.open();
            // 2.設定SocketChannel非阻塞模式， 這裡不設定TCP引數
            socketChannel.configureBlocking(false);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }


    @Override
    public void run() {
        try {
            // 連線服務端
            doConnect();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
        while (!stop) {
            try {
                // 6. 多路複用器線上程run方法的無限迴圈體內輪詢準備就緒的Key
                selector.select(1000);
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectedKeys.iterator();
                SelectionKey key = null;
                while (it.hasNext()) {
                    key = it.next();
                    it.remove();
                    try {
                        handleInput(key);
                    } catch (Exception e) {
                        if (key != null) {
                            key.cancel();
                            if (key.channel() != null) {
                                key.channel().close();
                            }
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }

        // 多路複用器關閉後，所有註冊在上面的Channel和Pipe等資源都會被自動去註冊並關閉，所以不需要重複釋放資源
        if (selector != null) {
            try {
                selector.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 處理客戶端輸入
     *
     * @param key
     * @throws IOException
     */
    private void handleInput(SelectionKey key) throws IOException {

        if (key.isValid()) {
            // 判斷是否連線成功
            SocketChannel sc = (SocketChannel) key.channel();
            // 7. 接收connect事件進行處理
            if (key.isConnectable()) {
                // 8. 如果連線完成則註冊讀事件到多路複用器
                if (sc.finishConnect()) {
                    sc.register(selector, SelectionKey.OP_READ);
                    doWrite(sc);
                } else {
                    System.exit(1);// 連線失敗，程式退出
                }
            }
            if (key.isReadable()) {
                ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                // 9. 非同步讀客戶端請求訊息到緩衝區
                int readBytes = sc.read(readBuffer);
                if (readBytes > 0) {
                    readBuffer.flip();
                    byte[] bytes = new byte[readBuffer.remaining()];
                    readBuffer.get(bytes);
                    String body = new String(bytes, "UTF-8");
                    System.out.println("Now is : " + body);
                    this.stop = true;
                } else if (readBytes < 0) {
                    // 對端鏈路關閉
                    key.cancel();
                    sc.close();
                } else {
                    // 讀到0位元組，忽略
                }
            }
        }

    }

    private void doConnect() throws IOException {
        // 3. 非同步連線客戶端
        boolean connected = socketChannel.connect(new InetSocketAddress(host, port));
        if (connected) {
            // 4. 返回true則直接連線成功，則註冊到多路複用器上，傳送請求訊息，讀應答
            socketChannel.register(selector, SelectionKey.OP_READ);
            doWrite(socketChannel);
        } else {
            // 5. 如果返回false，則說明此時鏈路還沒有建立，則註冊OP_CONNECT狀態位，監聽服務端的TCP ACK應答
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
        }
    }

    private void doWrite(SocketChannel sc) throws IOException {
        byte[] req = "QUERY TIME ORDER".getBytes();
        ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);
        writeBuffer.put(req);
        writeBuffer.flip();
        sc.write(writeBuffer);
        if (!writeBuffer.hasRemaining()) {
            System.out.println("Send order to server succeed.");
        }
    }
}

（2）NIO客戶端TimeClient

public class TimeClient {

    public static void main(String[] args) {
        int port = 8084;
        new Thread(new TimeClientHandle("127.0.0.1", port), "NIO-TimeClient").start();
    }
}

（3）執行客戶端

執行TimeClient：

此時服務端Console：

四、NIO程式設計的優點

1.NIO程式設計的優勢與缺點

（1）客戶端發起的連線操作是非同步的

　　可以通過在多路複用器註冊OP_CONNECT等待後續結果，不需要像之前的客戶端被同步阻塞。

（2）SocketChannel的讀寫操作都是非同步的

　　如果沒有可讀寫資料不會等待直接返回，I/O通訊執行緒就可以處理其他鏈路，不需要同步等待鏈路可用。

（3）執行緒模型的優化

　　Selector在Linux等主流系統上是通過epoll實現，沒有連線控制程式碼的限制，意味著一個Selector可以處理成千上萬的客戶端連線，而且效能不會降低

（4）同步非阻塞通訊

　　NIO需要開啟執行緒不斷迴圈去獲取操作結果，看起來不是很明智，真正有效的應該是基於非同步回撥獲取結果的，JDK 1.7以後就提供了非同步非堵塞的IO操作方式，所以人們叫它 AIO（Asynchronous IO），非同步 IO 是基於事件和回撥機制實現的。

2.Selector基本工作原理

　　首先，需要將 Channel 註冊到 Selector 中，這樣 Selector 才知道哪些 Channel 是它需要管理的。之後，Selector 會不斷地輪詢註冊在其上的 Channel 。如果某個 Channel 上面發生了讀或者寫事件，這個 Channel 就處於就緒狀態，會被 Selector 輪詢出來，然後通過 SelectionKey 可以獲取就緒 Channel 的集合，進行後續的 I/O 操作。

　　關於Selector操作的程式碼示例模板：

    // 建立 Selector
    Selector selector = Selector.open();
    channel.configureBlocking(false);
    // 註冊 Channel 到 Selector 中
    SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
    while(true) {
        // 通過 Selector 選擇 Channel 
        int readyChannels = selector.select();
        if (readyChannels == 0) {
            continue;
        }
        // 獲得可操作的 Channel
        Set selectedKeys = selector.selectedKeys();
        // 遍歷 SelectionKey 陣列
        Iterator<SelectionKey> 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();
        }
    }

相關文章