——日拱一卒，不期而至！你好，我是彤哥，本篇是netty系列的第七篇。簡介上一章我們一起學習了Java NIO的核心組件Buffer，它通常跟Channel一起使用，但是它們在網路IO中又該如何使用呢，今天我們將一起學習另一個NIO核心組件—— Selector ，沒有它可以說就乾不起來網路I ...

——日拱一卒，不期而至！

nio

你好，我是彤哥，本篇是netty系列的第七篇。

簡介

上一章我們一起學習了Java NIO的核心組件Buffer，它通常跟Channel一起使用，但是它們在網路IO中又該如何使用呢，今天我們將一起學習另一個NIO核心組件——Selector，沒有它可以說就乾不起來網路IO。

概念

我們先來看兩段Selector的註釋，見類java.nio.channels.Selector。

註釋I

A multiplexor of {@link SelectableChannel} objects.

它是SelectableChannel對象的多路復用器，從這裡我們也可以知道Java NIO實際上是多路復用IO。

SelectableChannel有幾個子類，你會非常熟悉：

DatagramChannel，UDP協議連接
SocketChannel，TCP協議連接
ServerSocketChannel，專門處理TCP協議Accept事件

我們有必要複習一下多路復用IO的流程：

multiplexing-io

第一階段通過select去輪詢檢查有沒有連接準備好數據，第二階段把數據從內核空間拷貝到用戶空間。

在Java中，就是通過Selector這個多路復用器來實現第一階段的。

註釋II

A selector may be created by invoking the {@link #open open} method of this class, which will use the system's default {@link java.nio.channels.spi.SelectorProvider selector provider} to create a new selector. A selector may also be created by invoking the {@link java.nio.channels.spi.SelectorProvider#openSelector openSelector} method of a custom selector provider. A selector remains open until it is closed via its {@link #close close} method.

Selector可以通過它自己的open()方法創建，它將通過預設的java.nio.channels.spi.SelectorProvider類創建一個新的Selector。也可以通過實現java.nio.channels.spi.SelectorProvider類的抽象方法openSelector()來自定義實現一個Selector。Selector一旦創建將會一直處於open狀態直到調用了close()方法為止。

那麼，預設使用的Selector究竟是哪個呢？

通過跟蹤源碼：

> java.nio.channels.Selector#open()
  1> java.nio.channels.spi.SelectorProvider#provider()
    1.1> sun.nio.ch.DefaultSelectorProvider#create() // 返回WindowsSelectorProvider
  2> sun.nio.ch.WindowsSelectorProvider#openSelector() // 返回WindowsSelectorImpl

可以看到，在Windows平臺下，預設實現的Provider是WindowsSelectorProvider，它的openSelector()方法返回的是WindowsSelectorImpl，它就是Windows平臺預設的Selector實現。

為什麼要提到在Windows平臺呢，難道在Linux下麵實現不一樣？

是滴，因為網路IO是跟操作系統息息相關的，不同的操作系統的實現可能都不一樣，Linux下麵JDK的實現完全不一樣，那麼我們為什麼沒有感知到呢？我的代碼在Windows下麵寫的，拿到Linux下麵不是一樣運行？那是Java虛擬機（或者說Java運行時環境）幫我們把這個事幹了，它屏蔽了跟操作系統相關的細節，這也是Java代碼可以“Write Once, Run Anywhere”的精髓所在。

Selector與Channel的關係

上面我們說了selector是多路復用器，它是在網路IO的第一階段用來輪詢檢查有沒有連接準備好數據的，那麼它和Channel是什麼關係呢？

nio

Selector通過不斷輪詢的方式同時監聽多個Channel的事件，註意，這裡是同時監聽，一旦有Channel準備好了，它就會返回這些準備好了的Channel，交給處理線程去處理。

所以，在NIO編程中，通過Selector我們就實現了一個線程同時處理多個連接請求的目標，也可以一定程式降低伺服器資源的消耗。

基本用法

創建Selector

通過調用Selector.open()方法是我們常用的方式：

Selector selector = Selector.open();

當然，也可以通過實現java.nio.channels.spi.SelectorProvider.openSelector()抽象方法自定義一個Selector。

將Channel註冊到Selector上

為了將Channel跟Selector綁定在一起，需要將Channel註冊到Selector上，調用Channel的register()方法即可：

channel.configureBlocking(false);

SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

Channel必須是非阻塞模式才能註冊到Selector上，所以，無法將一個FileChannel註冊到Selector，因為FileChannel沒有所謂的阻塞還是非阻塞模式，本文來源於工從號彤哥讀源碼。

註冊的時候第二個參數傳入的是監聽的事件，一共有四種事件：

Connect
Accept
Read
Write

當Channel觸發了某個事件，通常也叫作那個事件就緒了。比如，數據準備好可以讀取了就叫作讀就緒了，同樣地，還有寫就緒、連接就緒、接受就緒，當然後面兩個不常聽到。

在Java中，這四種監聽事件是定義在SelectionKey中的：

SelectionKey.OP_READ，值為 1 << 0 = 0000 0001
SelectionKey.OP_WRITE，值為 1 << 2 = 0000 0100
SelectionKey.OP_CONNECT，值為 1 << 3 = 0000 1000
SelectionKey.OP_ACCEPT，值為 1 << 4 = 0001 0000

所以，也可以通過位或命令監聽多個感興趣的事件：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

正如上面所看到的，Channel註冊到Selector後返回的是一個SelectionKey，所以SelectionKey又可以看作是Channel和Selector之間的一座橋梁，把兩者綁定在了一起。

SelectionKey具有以下幾個重要屬性：

interest set，感興趣的事件集
ready set，就緒的事件集
保存著的Channel
保存著的Selector
attached object，附件

interest set

裡面保存了註冊Channel到Selector時傳入的第二個參數，即感興趣的事件集。

int interestSet = selectionKey.interestOps();

boolean isInterestedInAccept  = interestSet & SelectionKey.OP_ACCEPT;
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;

可以通過位與運算查看是否註冊了相應的事件。

ready set

裡面保存了就緒了的事件集。

int readySet = selectionKey.readyOps();
selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

可以通過readyOps()方法獲取所有就緒了的事件，也可以通過isXxxable()方法檢查某個事件是否就緒。

保存的Channel和Selector

Channel  channel  = selectionKey.channel();

Selector selector = selectionKey.selector();

通過channel()和selector()方法可以獲取綁定的Channel和Selector。

attachment

可以調用attach(obj)方法綁定一個對象到SelectionKey上，併在後面需要用到的時候通過attachment()方法取出綁定的對象，也可以翻譯為附件，它可以看作是數據傳遞的一種媒介，跟ThreadLocal有點類似，在前面綁定數據，在後面使用。

selectionKey.attach(theObject);

Object attachedObj = selectionKey.attachment();

當然，也可以在註冊Channel到Selector的時候就綁定附件：

SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

Selector.select()

一旦將一個或多個Channel註冊到Selector上了，我們就可以調用它的select()方法了，它會返回註冊時感興趣的事件中就緒的事件，本文來源於工從號彤哥讀源碼。

select()方法有三種變體：

select()，無參數，阻塞直到某個Channel有就緒的事件了才返回（當然是我們註冊的感興趣的事件）
select(timeout)，帶超時，阻塞直到某個Channel有就緒的事件了，或者超時了才返回
selectNow()，立即返回，不會阻塞，不管有沒有就緒的Channel都立即返回

select()的返回值為int類型，表示兩次select()之間就緒的Channel，即使上一次調用select()時返回的就緒Channel沒有被處理，下一次調用select()也不會再返回上一次就緒的Channel。比如，第一次調用select()返回了一個就緒的Channel，但是沒有處理它，第二次調用select()時又有一個Channel就緒了，那也只會返回1，而不是2。

Selector.selectedKeys()

一旦調用select()方法返回了有就緒的Channel，我們就可以使用selectedKeys()方法來獲取就緒的Channel了。

Set<SelectionKey> selectedKeys = selector.selectedKeys();

然後，就可以遍歷這些SelectionKey來查看感興趣的事件是否就緒了：

Set<SelectionKey> selectedKeys = selector.selectedKeys();

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();
}

最後，一定要記得調用keyIterator.remove();移除已經處理的SelectionKey。

Selector.wakeup()

前面我們說了調用select()方法時，調用者線程會進入阻塞狀態，直到有就緒的Channel才會返回。其實也不一定，wakeup()就是用來破壞規則的，可以在另外一個線程調用wakeup()方法強行喚醒這個阻塞的線程，這樣select()方法也會立即返回。

如果調用wakeup()時並沒有線程阻塞在select()上，那麼，下一次調用select()將立即返回，不會進入阻塞狀態。這跟LockSupport.unpark()方法是比較類似的。

Selector.close()

調用close()方法將會關閉Selector，同時也會將關聯的SelectionKey失效，但不會關閉Channel。

舉個慄子

nio

public class EchoServer {
    public static void main(String[] args) throws IOException {
        // 創建一個Selector
        Selector selector = Selector.open();
        // 創建ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 綁定8080埠
        serverSocketChannel.bind(new InetSocketAddress(8080));
        // 設置為非阻塞模式，本文來源於工從號彤哥讀源碼
        serverSocketChannel.configureBlocking(false);
        // 將Channel註冊到selector上，並註冊Accept事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            // 阻塞在select上
            selector.select();

            // 如果使用的是select(timeout)或selectNow()需要判斷返回值是否大於0

            // 有就緒的Channel
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 遍歷selectKeys
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                // 如果是accept事件
                if (selectionKey.isAcceptable()) {
                    // 強制轉換為ServerSocketChannel
                    ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
                    SocketChannel socketChannel = ssc.accept();
                    System.out.println("accept new conn: " + socketChannel.getRemoteAddress());
                    socketChannel.configureBlocking(false);
                    // 將SocketChannel註冊到Selector上，並註冊讀事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (selectionKey.isReadable()) {
                    // 如果是讀取事件
                    // 強制轉換為SocketChannel
                    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                    // 創建Buffer用於讀取數據
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    // 將數據讀入到buffer中
                    int length = socketChannel.read(buffer);
                    if (length > 0) {
                        buffer.flip();
                        byte[] bytes = new byte[buffer.remaining()];
                        // 將數據讀入到byte數組中
                        buffer.get(bytes);

                        // 換行符會跟著消息一起傳過來
                        String content = new String(bytes, "UTF-8").replace("\r\n", "");
                        if (content.equalsIgnoreCase("quit")) {
                            selectionKey.cancel();
                            socketChannel.close();
                        } else {
                            System.out.println("receive msg: " + content);
                        }
                    }
                }
                iterator.remove();
            }
        }
    }
}

總結

今天我們學習了Java NIO核心組件Selector，到這裡，NIO的三個最重要的核心組件我們就學習完畢了，說實話，NIO這塊最重要的還是思維的問題，時刻記著在NIO中一個線程是可以處理多個連接的。

看著Java原生NIO實現網路編程似乎也沒什麼困難的嗎？那麼為什麼還要有Netty呢？下一章我們將正式進入Netty的學習之中，我們將在其中尋找答案。

最後，也歡迎來我的工從號彤哥讀源碼系統地學習源碼&架構的知識。

nio

7. 彤哥說netty系列之Java NIO核心組件之Selector

簡介

概念

註釋I