本文轉載自：[https://github.com/jasonGeng88/blog](https://github.com/jasonGeng88/blog)

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章將同步到我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《不可輕視的Java網路程式設計》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從計算機網路的基礎知識入手，一步步地學習Java網路基礎，從socket到nio、bio、aio和netty等網路程式設計知識，並且進行實戰，網路程式設計是每一個Java後端工程師必須要學習和理解的知識點，進一步來說，你還需要掌握Linux中的網路程式設計原理，包括IO模型、網路程式設計框架netty的進階原理，才能更完整地瞭解整個Java網路程式設計的知識體系，形成自己的知識框架。

為了更好地總結和檢驗你的學習成果，本系列文章也會提供部分知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

*   文章一：[JAVA 中原生的 socket 通訊機制](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md)

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%BD%93%E5%89%8D%E7%8E%AF%E5%A2%83)當前環境

1.  jdk == 1.8

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E4%BB%A3%E7%A0%81%E5%9C%B0%E5%9D%80)程式碼地址

git 地址：[https://github.com/jasonGeng88/java-network-programming](https://github.com/jasonGeng88/java-network-programming)

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E7%9F%A5%E8%AF%86%E7%82%B9)知識點

*   nio 下 I/O 阻塞與非阻塞實現
*   SocketChannel 介紹
*   I/O 多路複用的原理
*   事件選擇器與 SocketChannel 的關係
*   事件監聽型別
*   位元組緩衝 ByteBuffer 資料結構

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%9C%BA%E6%99%AF)場景

接著上一篇中的站點訪問問題，如果我們需要併發訪問10個不同的網站，我們該如何處理？

在上一篇中，我們使用了`java.net.socket`類來實現了這樣的需求，以一執行緒處理一連線的方式，並配以執行緒池的控制，貌似得到了當前的最優解。可是這裡也存在一個問題，連線處理是同步的，也就是併發數量增大後，大量請求會在佇列中等待，或直接異常丟擲。

為解決這問題，我們發現元兇處在“一執行緒一請求”上，如果一個執行緒能同時處理多個請求，那麼在高併發下效能上會大大改善。這裡就借住 JAVA 中的 nio 技術來實現這一模型。

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#nio-%E7%9A%84%E9%98%BB%E5%A1%9E%E5%AE%9E%E7%8E%B0)nio 的阻塞實現

關於什麼是 nio，從字面上理解為 New IO，就是為了彌補原本 I/O 上的不足，而在 JDK 1.4 中引入的一種新的 I/O 實現方式。簡單理解，就是它提供了 I/O 的阻塞與非阻塞的兩種實現方式（_當然，預設實現方式是阻塞的。_）。

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

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%BB%BA%E7%AB%8B%E8%BF%9E%E6%8E%A5)建立連線

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

類圖如下： [![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-01.jpg)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-01.jpg)

建立連線程式碼實現：

<pre>// 初始化 socket，建立 socket 與 channel 的繫結關係
SocketChannel socketChannel = SocketChannel.open();
// 初始化遠端連線地址
SocketAddress remote = new InetSocketAddress(this.host, port);
// I/O 處理設定阻塞，這也是預設的方式，可不設定
socketChannel.configureBlocking(true);
// 建立連線
socketChannel.connect(remote);</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E8%8E%B7%E5%8F%96-socket-%E8%BF%9E%E6%8E%A5)獲取 socket 連線

因為是同樣是 I/O 阻塞的實現，所以後面的關於 socket 輸入輸出流的處理，和上一篇的基本相同。唯一差別是，這裡需要透過 channel 來獲取 socket 連線。

*   獲取 socket 連線

<pre>Socket socket = socketChannel.socket();</pre>

*   處理輸入輸出流

<pre>PrintWriter pw = getWriter(socketChannel.socket());
BufferedReader br = getReader(socketChannel.socket());</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%AE%8C%E6%95%B4%E7%A4%BA%E4%BE%8B)完整示例

<pre>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));
    }
}</pre>

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#nio-%E7%9A%84%E9%9D%9E%E9%98%BB%E5%A1%9E%E5%AE%9E%E7%8E%B0)nio 的非阻塞實現

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90)原理分析

nio 的阻塞實現，基本與使用原生的 socket 類似，沒有什麼特別大的差別。

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

[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-02.jpg)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-02.jpg)

_我們主要觀察圖中的前三種 I/O 模型，關於非同步 I/O，一般需要依靠作業系統的支援，這裡不討論。_

從圖中可以發現，阻塞過程主要發生在兩個階段上：

*   第一階段：等待資料就緒；
*   第二階段：將已就緒的資料從核心緩衝區複製到使用者空間；

這裡產生了一個從核心到使用者空間的複製，主要是為了系統的效能最佳化考慮。假設，從網路卡讀到的資料直接返回給使用者空間，那勢必會造成頻繁的系統中斷，因為從網路卡讀到的資料不一定是完整的，可能斷斷續續的過來。透過核心緩衝區作為緩衝，等待緩衝區有足夠的資料，或者讀取完結後，進行一次的系統中斷，將資料返回給使用者，這樣就能避免頻繁的中斷產生。

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

* * *

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

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%88%9B%E5%BB%BA%E9%80%89%E6%8B%A9%E5%99%A8)建立選擇器

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

程式碼如下：

<pre>import java.nio.channels.Selector;

...

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

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%88%9B%E5%BB%BA%E9%9D%9E%E9%98%BB%E5%A1%9E-io)建立非阻塞 I/O

下面，我們來建立一個非阻塞的 `SocketChannel`，程式碼與阻塞實現型別，唯一不同是`socketChannel.configureBlocking(false)`。

_**注意：只有在`socketChannel.configureBlocking(false)`之後的程式碼，才是非阻塞的，如果`socketChannel.connect()`在設定非阻塞模式之前，那麼連線操作依舊是阻塞呼叫的。**_

<pre>SocketChannel socketChannel = SocketChannel.open();
SocketAddress remote = new InetSocketAddress(host, port);
// 設定非阻塞模式
socketChannel.configureBlocking(false);
socketChannel.connect(remote);</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%BB%BA%E7%AB%8B%E9%80%89%E6%8B%A9%E5%99%A8%E4%B8%8E-socket-%E7%9A%84%E5%85%B3%E8%81%94)建立選擇器與 socket 的關聯

選擇器與 socket 都建立好了，下一步就是將兩者進行關聯，好讓選擇器和監聽到 Socket 的變化。這裡採用了以 `SocketChannel` 主動註冊到選擇器的方式進行關聯繫結，這也就解釋了，為什麼不直接`new Socket()`，而是以`SocketChannel`的方式來建立 socket。

程式碼如下：

<pre>socketChannel.register(selector,
                        SelectionKey.OP_CONNECT
                        | SelectionKey.OP_READ
                        | SelectionKey.OP_WRITE);</pre>

上面程式碼，我們將 socketChannel 註冊到了選擇器中，並且對它的連線、可讀、可寫事件進行了監聽。

具體的事件監聽型別如下：

| 操作型別 | 值 | 描述 | 所屬物件 |
| --- | --- | --- | --- |
| OP_READ | 1 << 0 | 讀操作 | SocketChannel |
| OP_WRITE | 1 << 2 | 寫操作 | SocketChannel |
| OP_CONNECT | 1 << 3 | 連線socket操作 | SocketChannel |
| OP_ACCEPT | 1 << 4 | 接受socket操作 | ServerSocketChannel |

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E9%80%89%E6%8B%A9%E5%99%A8%E7%9B%91%E5%90%AC-socket-%E5%8F%98%E5%8C%96)選擇器監聽 socket 變化

現在，選擇器已經與我們關心的 socket 進行了關聯。下面就是感知事件的變化，然後呼叫相應的處理機制。

這裡與 Linux 下的 selector 有點不同，nio 下的 selecotr 不會去遍歷所有關聯的 socket。我們在註冊時設定了我們關心的事件型別，每次從選擇器中獲取的，只會是那些符合事件型別，並且完成就緒操作的 socket，減少了大量無效的遍歷操作。

```
public void select() throws IOException {
	// 獲取就緒的 socket 個數
    while (selector.select() > 0){

// 獲取符合的 socket 在選擇器中對應的事件控制程式碼 key
        Set keys = selector.selectedKeys();

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

// 獲取對應的 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()`是同步阻塞的，等待有事件發生後，才會被喚醒。這就防止了 CPU 空轉的產生。當然，我們也可以給它設定超時時間，`selector.select(long timeout)`來結束阻塞過程。**_

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%A4%84%E7%90%86%E8%BF%9E%E6%8E%A5%E5%B0%B1%E7%BB%AA%E4%BA%8B%E4%BB%B6)處理連線就緒事件

下面，我們分別來看下，一個 socket 是如何來處理連線、寫入資料和讀取資料的（_這些操作都是阻塞的過程，只是我們將等待就緒的過程變成了非阻塞的了_）。

處理連線程式碼：

<pre>// SelectionKey 代表 SocketChannel 在選擇器中註冊的事件控制程式碼
private void connect(SelectionKey key) throws IOException {
	// 獲取事件控制程式碼對應的 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));
}</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%A4%84%E7%90%86%E5%86%99%E5%85%A5%E5%B0%B1%E7%BB%AA%E4%BA%8B%E4%BB%B6)處理寫入就緒事件

<pre>// 字符集處理類
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 所關心的事件
    key.interestOps(SelectionKey.OP_READ);
}</pre>

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

*   第一個是使用 `channel.write(charset.encode(request));` 進行資料寫入。有人會說，為什麼不能像上面同步阻塞那樣，透過`PrintWriter`包裝類進行操作。因為`PrintWriter`的 `write()` 方法是阻塞的，也就是說要等資料真正從 socket 傳送出去後才返回。

這與我們這裡所講的阻塞是不一致的，這裡的操作雖然也是阻塞的，但它發生的過程是在資料從使用者空間到核心緩衝區複製過程。至於系統將緩衝區的資料透過 socket 傳送出去，這不在阻塞範圍內。也解釋了為什麼要用 `Charset` 對寫入內容進行編碼了，因為緩衝區接收的格式是`ByteBuffer`。

*   第二，選擇器用來監聽事件變化的兩個引數是 `interestOps` 與 `readyOps`。

*   interestOps：表示 `SocketChannel` 所關心的事件型別，也就是告訴選擇器，當有這幾種事件發生時，才來通知我。這裡透過`key.interestOps(SelectionKey.OP_READ);`告訴選擇器，之後我只關心“讀就緒”事件，其他的不用通知我了。

*   readyOps：表示 `SocketChannel` 當前就緒的事件型別。以`key.isReadable()`為例，判斷依據就是：`return (readyOps() & OP_READ) != 0;`

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%A4%84%E7%90%86%E8%AF%BB%E5%8F%96%E5%B0%B1%E7%BB%AA%E4%BA%8B%E4%BB%B6)處理讀取就緒事件

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

// 當再沒有資料可讀時，取消在選擇器中的關聯，並關閉 socket 連線
    if ("".equals(receiveData)) {
        key.cancel();
        channel.close();
        return;
    }

System.out.println(receiveData);
}</pre>

這裡的處理基本與寫入一致，唯一要注意的是，這裡我們需要自行處理去緩衝區讀取資料的操作。首先會分配一個固定大小的緩衝區，然後從核心緩衝區中，複製資料至我們剛分配固定緩衝區上。這裡存在兩種情況：

*   我們分配的緩衝區過大，那多餘的部分以0補充（_初始化時，其實會自動補0_）。
*   我們分配的緩衝去過小，因為選擇器會不停的遍歷。只要 `SocketChannel` 處理讀就緒狀態，那下一次會繼續讀取。當然，分配過小，會增加遍歷次數。

最後，將一下 `ByteBuffer` 的結構，它主要有 position, limit,capacity 以及 mark 屬性。以 `buffer.flip();` 為例，講下各屬性的作用（_mark 主要是用來標記之前 position 的位置，是在當前 postion 無法滿足的情況下使用的，這裡不作討論_）。

[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-03.png)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-03.png)

從圖中看出，

*   容量（capacity）：表示緩衝區可以儲存的資料容量；
*   極限（limit）：表示緩衝區的當前終點，即寫入、讀取都不可超過該重點；
*   位置（position）：表示緩衝區下一個讀寫單元的位置；

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%AE%8C%E6%95%B4%E4%BB%A3%E7%A0%81)完整程式碼

<pre>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);
    }
}
</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E7%A4%BA%E4%BE%8B%E6%95%88%E6%9E%9C)示例效果

[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-nio-04.png)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-nio-04.png)

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E6%80%BB%E7%BB%93)總結

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

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-nio.md#%E5%90%8E%E7%BB%AD)後續

*   Netty 下的非同步請求實現

Java網路程式設計與NIO詳解2：JAVA NIO 一步步構建IO多路複用的請求模型

相關文章