基於Java NIO 寫的一個簡單版 Netty 服務端

A Simple Netty Based On JAVA NIO

基於Java NIO 寫的一個簡單版 Netty 服務端

前置知識

NIO

• NIO 一般指 同步非阻塞 IO，同樣用於**描述程式訪問資料方式 **的還有BIO（同步阻塞）、AIO（非同步非阻塞）
• 同步非同步指獲取結果的方式，同步為主動去獲取結果，不管結果是否準備好，非同步為等待結果準備好的通知
• 阻塞非阻塞是執行緒在結果沒有到來之前，是否進行等待，阻塞為進行等待，非阻塞則不進行等待
• NIO 主動地去獲取結果，但是在結果沒有準備好之前，不會進行等待。而是透過一個 多路複用器 管理多個通道，由一個執行緒輪訓地去檢查是否準備好即可。在網路程式設計中，多路複用器通常由作業系統提供，Linux中主要有 select、poll、epoll。同步非阻塞指執行緒不等待資料的傳輸，而是完成後由多路複用器通知，執行緒再將資料從核心緩衝區複製到使用者空間記憶體進行處理。

Java NIO

• 基於 NIO 實現的網路框架，可以用少量的執行緒，處理大量的連線，更適用於高併發場景。於是，Java提供了NIO包提供相關元件，用於實現同步非阻塞IO
  • 核心三個類Channel、Buffer、Selector。Channel代表一個資料傳輸通道，但不進行資料存取，有Buffer類進行資料管理，Selector為一個複用器，管理多個通道

Bytebuffer

• 該類為NIO 包中用於操作記憶體的抽象類，具體實現由HeapByteBuffer、DirectByteBuffer兩種
• HeapByteBuffer為堆內記憶體，底層透過 byte[ ] 存取資料
• DirectByteBuffer 為堆外記憶體，透過JDK提供的 Unsafe類去存取；同時建立物件會關聯的一個Cleaner物件，當物件被GC時，透過cleaner物件去釋放堆外記憶體

各核心元件介紹

NioServer

為啟動程式類，監聽埠，初始化Channel

• 下面為NIO模式下簡單服務端處理程式碼

// 1、建立服務端Channel，繫結埠並配置非阻塞
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.socket().bind(new InetSocketAddress(6666));
serverSocketChannel.configureBlocking(false);

// 2、建立多路複用器selector，並將channel註冊到多路複用器上
// 不能直接呼叫channel的accept方法，因為屬於非阻塞，直接呼叫沒有新連線會直接返回
Selector selector = Selector.open();
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

// 3、迴圈處理多路複用器的IO事件
while(true){

    // 3.1、select屬於阻塞的方法，這裡阻塞等待1秒
    // 如果返回0，說明沒有事件處理
    if (selector.select(1000) == 0){
        System.out.println("伺服器等待了1秒，無IO事件");
        continue;
    }
    // 3.2、遍歷事件進行處理
    Set<SelectionKey> selectionKeys = selector.selectedKeys();
    Iterator<SelectionKey> iterator = selectionKeys.iterator();
    while(iterator.hasNext()){
        SelectionKey key = iterator.next();
        // accept事件，說明有新的客戶端連線
        if (key.isAcceptable()){
            // 新建一個socketChannel,註冊到selector,並關聯buffer
            SocketChannel socketChannel = serverSocketChannel.accept();
            socketChannel.configureBlocking(false);
            socketChannel.register(selector,SelectionKey.OP_READ, ByteBuffer.allocate(1024));
            System.out.println("客戶端連線:"+socketChannel.getRemoteAddress());
        }
        // read事件 (核心緩衝區的資料準備好了)
        if(key.isReadable()){
            SocketChannel channel = (SocketChannel)key.channel();
            ByteBuffer byteBuffer = (ByteBuffer)key.attachment();
            try {
              // 將資料寫進buffer
                int readNum = channel.read(byteBuffer);
                if (readNum == -1){
                    System.out.println("讀取-1時,表示IO流已結束");
                    channel.close();
                    break;
                }
                // 列印buffer
                byteBuffer.flip();
                byte[] bytes = new byte[readNum];
                byteBuffer.get(bytes, 0, readNum);
                System.out.println("讀取到資料:" + new String(bytes));
            } catch (IOException e) {
                System.out.println("讀取發生異常，廣播socket");
                channel.close();
            }

        }
        // write事件 (作業系統有記憶體寫出了)
        if (key.isWritable()){
            SocketChannel channel = (SocketChannel)key.channel();
            // 讀取read時暫存資料
            byte[] bytes = (byte[])key.attachment();
            if (bytes != null){
                System.out.println("可寫事件發生，寫入資料: " + new String(bytes));
                channel.write(ByteBuffer.wrap(bytes));
            }
            // 清空暫存資料，並切換成關注讀事件
            key.attach(null);
            key.interestOps(SelectionKey.OP_READ);
        }
        iterator.remove();
    }
}

EventLoop

處理 Channel 中資料的讀寫

• 在上面的Server中，大量併發時單執行緒地處理讀寫事件會導致延遲，因此將讀寫處理抽取出來，可利用多執行緒實現高併發
• 一個EventLoop會關聯一個selector，只會處理這個selector上的Channel

public class EventLoop2 implements Runnable{


    private final Thread thread;
    /**
     * 複用器，當前執行緒只處理這個複用器上的channel
     */
    public Selector selector;
    /**
     * 待處理的註冊任務
     */
    private final Queue<Runnable> queue = new LinkedBlockingQueue<>();

    /**
     * 初始化複用器，執行緒啟動
     * @throws IOException
     */
    public EventLoop2() throws IOException {
        this.selector = SelectorProvider.provider().openSelector();
        this.thread = new Thread(this);
        thread.start();
    }

    /**
     * 將通道註冊給當前的執行緒處理
     * @param socketChannel
     * @param keyOps
     */
    public void register(SocketChannel socketChannel,int keyOps){
        // 將註冊新的socketChannel到當前selector封裝成一個任務
        queue.add(()->{
            try {
                MyChannel myChannel = new MyChannel(socketChannel, this);
                SelectionKey key = socketChannel.register(selector, keyOps);
                key.attach(myChannel);
            } catch (Exception e){
                e.printStackTrace();
            }
        });
        // 喚醒阻塞等待的selector執行緒
        selector.wakeup();
    }

    /**
     * 迴圈地處理 註冊事件、讀寫事件
     */
    @Override
    public void run() {
        while (!thread.isInterrupted()){
            try {
                int select = selector.select(1000);
                // 處理註冊到當前selector的事件
                if (select == 0){
                    Runnable task;
                    while ((task = queue.poll()) != null){
                        task.run();
                    }
                    continue;
                }
                // 處理讀寫事件
                System.out.println("伺服器收到讀寫事件,select:" + select);
                processReadWrite();

            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    /**
     * 處理讀寫事件
     * @throws Exception
     */
    private void processReadWrite() throws Exception{
        System.out.println(Thread.currentThread() + "開始監聽讀寫事件");
        // 3.2、遍歷事件進行處理
        Set<SelectionKey> selectionKeys = selector.selectedKeys();
        Iterator<SelectionKey> iterator = selectionKeys.iterator();
        while(iterator.hasNext()){
            SelectionKey key = iterator.next();
            MyChannel myChannel = (MyChannel)key.attachment();
            if(key.isReadable()){
                // 將資料讀進buffer
                myChannel.doRead(key);
            }
            if (key.isWritable()){
                myChannel.doWrite(key);
            }
            iterator.remove();
        }
    }
}

EventloopGroup

一組EventLoop，輪訓地為eventLoop分配Channel

public class EventLoopGroup {
    private EventLoop2[] children = new EventLoop2[1];

    private AtomicInteger idx = new AtomicInteger(0);

    public EventLoopGroup() throws IOException {
        for (int i = 0; i < children.length; i++){
            children[i] = new EventLoop2();
        }
    }

    public EventLoop2 next(){
        // 輪訓每一個children
        return children[idx.getAndIncrement() & (children.length - 1)];
    }

    public void register(SocketChannel channel,int ops){
        next().register(channel,ops);
    }
}

Channel

封裝了SocketChannel 和 Pipline，將從Channel讀寫的訊息，沿著Pipline上的節點進行處理

• 在上面EventLoop中，註冊Channel到對應的Selector前，會進行封裝，將自定義的Channel放在讀寫事件觸發時會返回的SelectionKey裡面
• 同時提供了資料讀寫處理方法，讀寫事件觸發時呼叫該方法，資料會沿著pipline上去處理

public class MyChannel {

    private SocketChannel channel;

    private EventLoop2 eventLoop;

    private Queue<ByteBuffer> writeQueue;

    private PipLine pipLine;

    /**
     * 一個channel關聯一個eventLoop、一個pipLine、一個socketChannel、一個writeQueue
     * @param channel
     * @param eventLoop
     */
    public MyChannel(SocketChannel channel, EventLoop2 eventLoop) {
        this.channel = channel;
        this.eventLoop = eventLoop;
        this.writeQueue = new ArrayDeque<>();
        this.pipLine = new PipLine(this,eventLoop);
        this.pipLine.addLast(new MyHandler1());
        this.pipLine.addLast(new MyHandler2());
    }

    /**
     * 讀事件處理
     * @param key
     * @throws Exception
     */
    public void doRead(SelectionKey key) throws Exception{
        try {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int readNum = channel.read(buffer);
            if (readNum == -1){
                System.out.println("讀取-1時,表示IO流已結束");
                channel.close();
                return;
            }
            // 轉成可讀狀態
            buffer.flip();
            // 訊息放入pipLine，交給頭節點, 頭節點開始傳遞
            pipLine.headContext.fireChannelRead(buffer);

        } catch (IOException e) {
            System.out.println("讀取發生異常，廣播socket");
            channel.close();
        }
    }

    /**
     * 真正地寫出資料，關注寫事件後，會觸發
     * @param key
     * @throws IOException
     */
    public void doWrite(SelectionKey key) throws IOException{
        ByteBuffer buffer;
        while ((buffer =writeQueue.poll()) != null){
            channel.write(buffer);
        }
        // 回覆讀取狀態
        key.interestOps(SelectionKey.OP_READ);

    }

    /**
     * 寫出到佇列
     * @param msg
     */
    public void doWriteQueue(ByteBuffer msg){
        writeQueue.add(msg);
    }

    /**
     * 從最後一個節點進行寫出，寫出到頭節點是呼叫doWriteQueue
     * @param msg
     */
    public void write(Object msg){
        this.pipLine.tailContext.write(msg);
    }

    /**
     * 從最後一個節點進行flush，寫出到頭節點時呼叫doFlush
     */
    public void flush(){
        this.pipLine.tailContext.flush();
    }

    /**
     * 關注寫事件，才能進行真正地寫出
     */
    public void doFlush(){
        this.channel.keyFor(eventLoop.selector).interestOps(SelectionKey.OP_WRITE);
    }

}

Handler 和 HandlerContext

handler 介面定義了可以擴充套件處理的訊息，由開發人員實現具體的處理

handlerContext 類封裝了handler的實現類，將handler的上一個節點和下一個節點，讓訊息可以延者連結串列傳遞

public interface Handler {

    /**
     * 讀取資料處理
     * @param ctx
     * @param msg
     */
    void channelRead(HandlerContext ctx,Object msg);

    /**
     * 寫出資料
     * @param ctx
     * @param msg
     */
    void write(HandlerContext ctx,Object msg);

    /**
     * 刷下資料
     * @param ctx
     */
    void flush(HandlerContext ctx);
}

public class HandlerContext {

    private Handler handler;

    MyChannel channel;

    HandlerContext prev;

    HandlerContext next;

    public HandlerContext(Handler handler, MyChannel channel) {
        this.handler = handler;
        this.channel = channel;
    }

    /**
     * 讀訊息的傳遞，從頭節點開始往後傳
     * @param msg
     */
    public void fireChannelRead(Object msg){
        HandlerContext next = this.next;
        if (next != null){
            next.handler.channelRead(next,msg);
        }
    }

    /**
     * 從尾節點開始往前傳
     * @param msg
     */
    public void write(Object msg){
        HandlerContext prev = this.prev;
        if (prev != null){
            prev.handler.write(prev,msg);
        }
    }

    /**
     * 從尾節點開始往前傳
     */
    public void flush(){
        HandlerContext prev = this.prev;
        if (prev != null){
            prev.handler.flush(prev);
        }
    }
}

Pipline

本質是連結串列，包含了頭尾節點的HandlerContext，提供方法給開發人員加節點

public class PipLine {

    private MyChannel channel;

    private EventLoop2 eventLoop;

    public HandlerContext headContext;

    public HandlerContext tailContext;

    public PipLine(MyChannel channel, EventLoop2 eventLoop) {
        this.channel = channel;
        this.eventLoop = eventLoop;
        PipHandler headHandler = new PipHandler();
        this.headContext = new HandlerContext(headHandler,channel);
        PipHandler tailHandler = new PipHandler();
        this.tailContext = new HandlerContext(tailHandler,channel);
        // 構建連結串列
        this.headContext.next = this.tailContext;
        this.tailContext.prev = this.headContext;
    }

    public void addLast(Handler handler){
        HandlerContext curr = new HandlerContext(handler, channel);

        // 連線在倒數第二個後面
        HandlerContext lastButOne = this.tailContext.prev;
        lastButOne.next = curr;
        curr.prev = lastButOne;

        // 連線在最後一個前面
        curr.next = tailContext;
        tailContext.prev = curr;

    }

    public static class PipHandler implements Handler{

        @Override
        public void channelRead(HandlerContext ctx, Object msg) {
            System.out.println("接收"+(String) msg +"進行資源釋放");
        }

        @Override
        public void write(HandlerContext ctx, Object msg) {
            System.out.println("寫出"+msg.toString());
        }

        @Override
        public void flush(HandlerContext ctx) {
            System.out.println("flush");
        }
    }
}