摘要：為解決這問題，我們發(fā)現(xiàn)元兇處在一線程一請求上，如果一個線程能同時處理多個請求，那么在高并發(fā)下性能上會大大改善。這樣一個線程可以同時發(fā)起多個調(diào)用，并且不需要同步等待數(shù)據(jù)就緒。表示當(dāng)前就緒的事件類型。

摘要：本文屬于原創(chuàng)，歡迎轉(zhuǎn)載，轉(zhuǎn)載請保留出處：https://github.com/jasonGeng88/blog

文章一：JAVA 中原生的 socket 通信機制

jdk == 1.8

git 地址：https://github.com/jasonGeng88/java-network-programming

nio 下 I/O 阻塞與非阻塞實現(xiàn)

SocketChannel 介紹

I/O 多路復(fù)用的原理

事件選擇器與 SocketChannel 的關(guān)系

事件監(jiān)聽類型

字節(jié)緩沖 ByteBuffer 數(shù)據(jù)結(jié)構(gòu)

接著上一篇中的站點訪問問題，如果我們需要并發(fā)訪問10個不同的網(wǎng)站，我們該如何處理？

在上一篇中，我們使用了java.net.socket類來實現(xiàn)了這樣的需求，以一線程處理一連接的方式，并配以線程池的控制，貌似得到了當(dāng)前的最優(yōu)解。可是這里也存在一個問題，連接處理是同步的，也就是并發(fā)數(shù)量增大后，大量請求會在隊列中等待，或直接異常拋出。

為解決這問題，我們發(fā)現(xiàn)元兇處在“一線程一請求”上，如果一個線程能同時處理多個請求，那么在高并發(fā)下性能上會大大改善。這里就借住 JAVA 中的 nio 技術(shù)來實現(xiàn)這一模型。

關(guān)于什么是 nio，從字面上理解為 New IO，就是為了彌補原本 I/O 上的不足，而在 JDK 1.4 中引入的一種新的 I/O 實現(xiàn)方式。簡單理解，就是它提供了 I/O 的阻塞與非阻塞的兩種實現(xiàn)方式（當(dāng)然，默認實現(xiàn)方式是阻塞的。）。

下面，我們先來看下 nio 以阻塞方式是如何處理的。

有了上一篇 socket 的經(jīng)驗，我們的第一步一定也是建立 socket 連接。只不過，這里不是采用 new socket() 的方式，而是引入了一個新的概念 SocketChannel。它可以看作是 socket 的一個完善類，除了提供 Socket 的相關(guān)功能外，還提供了許多其他特性，如后面要講到的向選擇器注冊的功能。

類圖如下：

建立連接代碼實現(xiàn)：

// 初始化 socket，建立 socket 與 channel 的綁定關(guān)系
SocketChannel socketChannel = SocketChannel.open();
// 初始化遠程連接地址
SocketAddress remote = new InetSocketAddress(this.host, port);
// I/O 處理設(shè)置阻塞，這也是默認的方式，可不設(shè)置
socketChannel.configureBlocking(true);
// 建立連接
socketChannel.connect(remote);

因為是同樣是 I/O 阻塞的實現(xiàn)，所以后面的關(guān)于 socket 輸入輸出流的處理，和上一篇的基本相同。唯一差別是，這里需要通過 channel 來獲取 socket 連接。

獲取 socket 連接

Socket socket = socketChannel.socket();

處理輸入輸出流

PrintWriter pw = getWriter(socketChannel.socket());
BufferedReader br = getReader(socketChannel.socket());

package com.jason.network.mode.nio;

import com.jason.network.constant.HttpConstant;
import com.jason.network.util.HttpUtil;

import java.io.*;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.channels.SocketChannel;

public class NioBlockingHttpClient {

    private SocketChannel socketChannel;
    private String host;


    public static void main(String[] args) throws IOException {

        for (String host: HttpConstant.HOSTS) {

            NioBlockingHttpClient client = new NioBlockingHttpClient(host, HttpConstant.PORT);
            client.request();

        }

    }

    public NioBlockingHttpClient(String host, int port) throws IOException {
        this.host = host;
        socketChannel = SocketChannel.open();
        socketChannel.socket().setSoTimeout(5000);
        SocketAddress remote = new InetSocketAddress(this.host, port);
        this.socketChannel.connect(remote);
    }

    public void request() throws IOException {
        PrintWriter pw = getWriter(socketChannel.socket());
        BufferedReader br = getReader(socketChannel.socket());

        pw.write(HttpUtil.compositeRequest(host));
        pw.flush();
        String msg;
        while ((msg = br.readLine()) != null){
            System.out.println(msg);
        }
    }

    private PrintWriter getWriter(Socket socket) throws IOException {
        OutputStream out = socket.getOutputStream();
        return new PrintWriter(out);
    }

    private BufferedReader getReader(Socket socket) throws IOException {
        InputStream in = socket.getInputStream();
        return new BufferedReader(new InputStreamReader(in));
    }
}

nio 的阻塞實現(xiàn)，基本與使用原生的 socket 類似，沒有什么特別大的差別。

下面我們來看看它真正強大的地方。到目前為止，我們將的都是阻塞 I/O。何為阻塞 I/O，看下圖：

我們主要觀察圖中的前三種 I/O 模型，關(guān)于異步 I/O，一般需要依靠操作系統(tǒng)的支持，這里不討論。

從圖中可以發(fā)現(xiàn)，阻塞過程主要發(fā)生在兩個階段上：

第一階段：等待數(shù)據(jù)就緒；

第二階段：將已就緒的數(shù)據(jù)從內(nèi)核緩沖區(qū)拷貝到用戶空間；

這里產(chǎn)生了一個從內(nèi)核到用戶空間的拷貝，主要是為了系統(tǒng)的性能優(yōu)化考慮。假設(shè)，從網(wǎng)卡讀到的數(shù)據(jù)直接返回給用戶空間，那勢必會造成頻繁的系統(tǒng)中斷，因為從網(wǎng)卡讀到的數(shù)據(jù)不一定是完整的，可能斷斷續(xù)續(xù)的過來。通過內(nèi)核緩沖區(qū)作為緩沖，等待緩沖區(qū)有足夠的數(shù)據(jù)，或者讀取完結(jié)后，進行一次的系統(tǒng)中斷，將數(shù)據(jù)返回給用戶，這樣就能避免頻繁的中斷產(chǎn)生。

了解了 I/O 阻塞的兩個階段，下面我們進入正題。看看一個線程是如何實現(xiàn)同時處理多個 I/O 調(diào)用的。從上圖中的非阻塞 I/O 可以看出，僅僅只有第二階段需要阻塞，第一階段的數(shù)據(jù)等待過程，我們是不需要關(guān)心的。不過該模型是頻繁地去檢查是否就緒，造成了 CPU 無效的處理，反而效果不好。如果有一種類似的好萊塢原則— “不要給我們打電話，我們會打給你” 。這樣一個線程可以同時發(fā)起多個 I/O 調(diào)用，并且不需要同步等待數(shù)據(jù)就緒。在數(shù)據(jù)就緒完成的時候，會以事件的機制，來通知我們。這樣不就實現(xiàn)了單線程同時處理多個 IO 調(diào)用的問題了嗎？即所說的“I/O 多路復(fù)用模型”。

廢話講了一大堆，下面就來實際操刀一下。

由上面分析可以，我們得有一個選擇器，它能監(jiān)聽所有的 I/O 操作，并且以事件的方式通知我們哪些 I/O 已經(jīng)就緒了。

代碼如下：

import java.nio.channels.Selector;

...

private static Selector selector;
static {
    try {
        selector = Selector.open();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

下面，我們來創(chuàng)建一個非阻塞的 SocketChannel，代碼與阻塞實現(xiàn)類型，唯一不同是socketChannel.configureBlocking(false)。

注意：只有在socketChannel.configureBlocking(false)之后的代碼，才是非阻塞的，如果socketChannel.connect()在設(shè)置非阻塞模式之前，那么連接操作依舊是阻塞調(diào)用的。

SocketChannel socketChannel = SocketChannel.open();
SocketAddress remote = new InetSocketAddress(host, port);
// 設(shè)置非阻塞模式
socketChannel.configureBlocking(false);
socketChannel.connect(remote);

選擇器與 socket 都創(chuàng)建好了，下一步就是將兩者進行關(guān)聯(lián)，好讓選擇器和監(jiān)聽到 Socket 的變化。這里采用了以 SocketChannel 主動注冊到選擇器的方式進行關(guān)聯(lián)綁定，這也就解釋了，為什么不直接new Socket()，而是以SocketChannel的方式來創(chuàng)建 socket。

代碼如下：

socketChannel.register(selector,
                        SelectionKey.OP_CONNECT
                        | SelectionKey.OP_READ
                        | SelectionKey.OP_WRITE);

上面代碼，我們將 socketChannel 注冊到了選擇器中，并且對它的連接、可讀、可寫事件進行了監(jiān)聽。

具體的事件監(jiān)聽類型如下：

現(xiàn)在，選擇器已經(jīng)與我們關(guān)心的 socket 進行了關(guān)聯(lián)。下面就是感知事件的變化，然后調(diào)用相應(yīng)的處理機制。

這里與 Linux 下的 selector 有點不同，nio 下的 selecotr 不會去遍歷所有關(guān)聯(lián)的 socket。我們在注冊時設(shè)置了我們關(guān)心的事件類型，每次從選擇器中獲取的，只會是那些符合事件類型，并且完成就緒操作的 socket，減少了大量無效的遍歷操作。

public void select() throws IOException {
    // 獲取就緒的 socket 個數(shù)
    while (selector.select() > 0){
    
        // 獲取符合的 socket 在選擇器中對應(yīng)的事件句柄 key
        Set keys = selector.selectedKeys();

        // 遍歷所有的key
        Iterator it = keys.iterator();
        while (it.hasNext()){

            // 獲取對應(yīng)的 key，并從已選擇的集合中移除
            SelectionKey key = (SelectionKey)it.next();
            it.remove();

            if (key.isConnectable()){
                // 進行連接操作
                connect(key);
            }
            else if (key.isWritable()){
                // 進行寫操作
                write(key);
            }
            else if (key.isReadable()){
                // 進行讀操作
                receive(key);
            }
        }
    }
}

注意：這里的selector.select()是同步阻塞的，等待有事件發(fā)生后，才會被喚醒。這就防止了 CPU 空轉(zhuǎn)的產(chǎn)生。當(dāng)然，我們也可以給它設(shè)置超時時間，selector.select(long timeout)來結(jié)束阻塞過程。

下面，我們分別來看下，一個 socket 是如何來處理連接、寫入數(shù)據(jù)和讀取數(shù)據(jù)的（這些操作都是阻塞的過程，只是我們將等待就緒的過程變成了非阻塞的了）。

處理連接代碼：

// SelectionKey 代表 SocketChannel 在選擇器中注冊的事件句柄
private void connect(SelectionKey key) throws IOException {
    // 獲取事件句柄對應(yīng)的 SocketChannel
    SocketChannel channel = (SocketChannel) key.channel();
    
   // 真正的完成 socket 連接
    channel.finishConnect();
    
   // 打印連接信息
    InetSocketAddress remote = (InetSocketAddress) channel.socket().getRemoteSocketAddress();
    String host = remote.getHostName();
    int port = remote.getPort();
    System.out.println(String.format("訪問地址: %s:%s 連接成功!", host, port));
}

// 字符集處理類
private Charset charset = Charset.forName("utf8");

private void write(SelectionKey key) throws IOException {
    SocketChannel channel = (SocketChannel) key.channel();
    InetSocketAddress remote = (InetSocketAddress) channel.socket().getRemoteSocketAddress();
    String host = remote.getHostName();

    // 獲取 HTTP 請求，同上一篇
    String request = HttpUtil.compositeRequest(host);

    // 向 SocketChannel 寫入事件 
    channel.write(charset.encode(request));
    
    // 修改 SocketChannel 所關(guān)心的事件
    key.interestOps(SelectionKey.OP_READ);
}

這里有兩個地方需要注意：

第一個是使用 channel.write(charset.encode(request)); 進行數(shù)據(jù)寫入。有人會說，為什么不能像上面同步阻塞那樣，通過PrintWriter包裝類進行操作。因為PrintWriter的 write() 方法是阻塞的，也就是說要等數(shù)據(jù)真正從 socket 發(fā)送出去后才返回。

這與我們這里所講的阻塞是不一致的，這里的操作雖然也是阻塞的，但它發(fā)生的過程是在數(shù)據(jù)從用戶空間到內(nèi)核緩沖區(qū)拷貝過程。至于系統(tǒng)將緩沖區(qū)的數(shù)據(jù)通過 socket 發(fā)送出去，這不在阻塞范圍內(nèi)。也解釋了為什么要用 Charset 對寫入內(nèi)容進行編碼了，因為緩沖區(qū)接收的格式是ByteBuffer。

第二，選擇器用來監(jiān)聽事件變化的兩個參數(shù)是 interestOps 與 readyOps。

interestOps：表示 SocketChannel 所關(guān)心的事件類型，也就是告訴選擇器，當(dāng)有這幾種事件發(fā)生時，才來通知我。這里通過key.interestOps(SelectionKey.OP_READ);告訴選擇器，之后我只關(guān)心“讀就緒”事件，其他的不用通知我了。

readyOps：表示 SocketChannel 當(dāng)前就緒的事件類型。以key.isReadable()為例，判斷依據(jù)就是：return (readyOps() & OP_READ) != 0;

private void receive(SelectionKey key) throws IOException {
    SocketChannel channel = (SocketChannel) key.channel();
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    channel.read(buffer);
    buffer.flip();
    String receiveData = charset.decode(buffer).toString();

    // 當(dāng)再沒有數(shù)據(jù)可讀時，取消在選擇器中的關(guān)聯(lián)，并關(guān)閉 socket 連接
    if ("".equals(receiveData)) {
        key.cancel();
        channel.close();
        return;
    }

    System.out.println(receiveData);
}

這里的處理基本與寫入一致，唯一要注意的是，這里我們需要自行處理去緩沖區(qū)讀取數(shù)據(jù)的操作。首先會分配一個固定大小的緩沖區(qū)，然后從內(nèi)核緩沖區(qū)中，拷貝數(shù)據(jù)至我們剛分配固定緩沖區(qū)上。這里存在兩種情況：

我們分配的緩沖區(qū)過大，那多余的部分以0補充（初始化時，其實會自動補0）。

我們分配的緩沖去過小，因為選擇器會不停的遍歷。只要 SocketChannel 處理讀就緒狀態(tài)，那下一次會繼續(xù)讀取。當(dāng)然，分配過小，會增加遍歷次數(shù)。

最后，將一下 ByteBuffer 的結(jié)構(gòu)，它主要有 position, limit,capacity 以及 mark 屬性。以 buffer.flip(); 為例，講下各屬性的作用（mark 主要是用來標記之前 position 的位置，是在當(dāng)前 postion 無法滿足的情況下使用的，這里不作討論）。

從圖中看出，

容量（capacity）：表示緩沖區(qū)可以保存的數(shù)據(jù)容量；

極限（limit）：表示緩沖區(qū)的當(dāng)前終點，即寫入、讀取都不可超過該重點；

位置（position）：表示緩沖區(qū)下一個讀寫單元的位置；

package com.jason.network.mode.nio;

import com.jason.network.constant.HttpConstant;
import com.jason.network.util.HttpUtil;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Set;

public class NioNonBlockingHttpClient {

    private static Selector selector;
    private Charset charset = Charset.forName("utf8");

    static {
        try {
            selector = Selector.open();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public static void main(String[] args) throws IOException {

        NioNonBlockingHttpClient client = new NioNonBlockingHttpClient();

        for (String host: HttpConstant.HOSTS) {

            client.request(host, HttpConstant.PORT);

        }

        client.select();

    }

    public void request(String host, int port) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.socket().setSoTimeout(5000);
        SocketAddress remote = new InetSocketAddress(host, port);
        socketChannel.configureBlocking(false);
        socketChannel.connect(remote);
        socketChannel.register(selector,
                        SelectionKey.OP_CONNECT
                        | SelectionKey.OP_READ
                        | SelectionKey.OP_WRITE);
    }

    public void select() throws IOException {
        while (selector.select(500) > 0){
            Set keys = selector.selectedKeys();

            Iterator it = keys.iterator();

            while (it.hasNext()){

                SelectionKey key = (SelectionKey)it.next();
                it.remove();

                if (key.isConnectable()){
                    connect(key);
                }
                else if (key.isWritable()){
                    write(key);
                }
                else if (key.isReadable()){
                    receive(key);
                }
            }
        }
    }

    private void connect(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        channel.finishConnect();
        InetSocketAddress remote = (InetSocketAddress) channel.socket().getRemoteSocketAddress();
        String host = remote.getHostName();
        int port = remote.getPort();
        System.out.println(String.format("訪問地址: %s:%s 連接成功!", host, port));
    }

    private void write(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        InetSocketAddress remote = (InetSocketAddress) channel.socket().getRemoteSocketAddress();
        String host = remote.getHostName();

        String request = HttpUtil.compositeRequest(host);
        System.out.println(request);

        channel.write(charset.encode(request));
        key.interestOps(SelectionKey.OP_READ);
    }

    private void receive(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        channel.read(buffer);
        buffer.flip();
        String receiveData = charset.decode(buffer).toString();

        if ("".equals(receiveData)) {
            key.cancel();
            channel.close();
            return;
        }

        System.out.println(receiveData);
    }
}

本文從 nio 的阻塞方式講起，介紹了阻塞 I/O 與非阻塞 I/O 的區(qū)別，以及在 nio 下是如何一步步構(gòu)建一個 IO 多路復(fù)用的模型的客戶端。文中需要理解的內(nèi)容比較多，如果有理解錯誤的地方，歡迎指正~

Netty 下的異步請求實現(xiàn)