Socket粘包問題的3種解決方案，最後一種最完美！

• 2021 年 1 月 6 日
• 筆記
• core-java, JAVA

在 Java 語言中，傳統的 Socket 編程分為兩種實現方式，這兩種實現方式也對應着兩種不同的傳輸層協議：TCP 協議和 UDP 協議，但作為互聯網中最常用的傳輸層協議 TCP，在使用時卻會導致粘包和半包問題，於是為了徹底的解決此問題，便誕生了此篇文章。

什麼是 TCP 協議？

TCP 全稱是 Transmission Control Protocol（傳輸控制協議），它由 IETF 的 RFC 793 定義，是一種面向連接的點對點的傳輸層通信協議。

TCP 通過使用序列號和確認消息，從發送節點提供有關傳輸到目標節點的數據包的傳遞的信息。TCP 確保數據的可靠性，端到端傳遞，重新排序和重傳，直到達到超時條件或接收到數據包的確認為止。

TCP 是 Internet 上最常用的協議，它也是實現 HTTP（HTTP 1.0/HTTP 2.0）通訊的基礎，當我們在瀏覽器中請求網頁時，計算機會將 TCP 數據包發送到 Web 服務器的地址，要求它將網頁返還給我們，Web 服務器通過發送 TCP 數據包流進行響應，然後瀏覽器將這些數據包縫合在一起以形成網頁。

TCP 的全部意義在於它的可靠性，它通過對數據包編號來對其進行排序，而且它會通過讓服務器將響應發送回瀏覽器說「已收到」來進行錯誤檢查，因此在傳輸過程中不會丟失或破壞任何數據。

目前市場上主流的 HTTP 協議使用的版本是 HTTP/1.1，如下圖所示：

什麼是粘包和半包問題？

粘包問題是指當發送兩條消息時，比如發送了 ABC 和 DEF，但另一端接收到的卻是 ABCD，像這種一次性讀取了兩條數據的情況就叫做粘包（正常情況應該是一條一條讀取的）。

半包問題是指，當發送的消息是 ABC 時，另一端卻接收到的是 AB 和 C 兩條信息，像這種情況就叫做半包。

為什麼會有粘包和半包問題？

這是因為 TCP 是面向連接的傳輸協議，TCP 傳輸的數據是以流的形式，而流數據是沒有明確的開始結尾邊界，所以 TCP 也沒辦法判斷哪一段流屬於一個消息。

粘包的主要原因：

• 發送方每次寫入數據 < 套接字（Socket）緩衝區大小；
• 接收方讀取套接字（Socket）緩衝區數據不夠及時。

半包的主要原因：

• 發送方每次寫入數據 > 套接字（Socket）緩衝區大小；
• 發送的數據大於協議的 MTU (Maximum Transmission Unit，最大傳輸單元)，因此必須拆包。

小知識點：什麼是緩衝區？

緩衝區又稱為緩存，它是內存空間的一部分。也就是說，在內存空間中預留了一定的存儲空間，這些存儲空間用來緩衝輸入或輸出的數據，這部分預留的空間就叫做緩衝區。

緩衝區的優勢以文件流的寫入為例，如果我們不使用緩衝區，那麼每次寫操作 CPU 都會和低速存儲設備也就是磁盤進行交互，那麼整個寫入文件的速度就會受制於低速的存儲設備（磁盤）。但如果使用緩衝區的話，每次寫操作會先將數據保存在高速緩衝區內存上，當緩衝區的數據到達某個閾值之後，再將文件一次性寫入到磁盤上。因為內存的寫入速度遠遠大於磁盤的寫入速度，所以當有了緩衝區之後，文件的寫入速度就被大大提升了。

粘包和半包問題演示

接下來我們用代碼來演示一下粘包和半包問題，為了演示的直觀性，我會設置兩個角色：

• 服務器端用來接收消息；
• 客戶端用來發送一段固定的消息。

然後通過打印服務器端接收到的信息來觀察粘包和半包問題。

服務器端代碼如下：

/**
 * 服務器端（只負責接收消息）
 */
class ServSocket {
    // 位元組數組的長度
    private static final int BYTE_LENGTH = 20;  
    public static void main(String[] args) throws IOException {
        // 創建 Socket 服務器
        ServerSocket serverSocket = new ServerSocket(9999);
        // 獲取客戶端連接
        Socket clientSocket = serverSocket.accept();
        // 得到客戶端發送的流對象
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                // 循環獲取客戶端發送的信息
                byte[] bytes = new byte[BYTE_LENGTH];
                // 讀取客戶端發送的信息
                int count = inputStream.read(bytes, 0, BYTE_LENGTH);
                if (count > 0) {
                    // 成功接收到有效消息並打印
                    System.out.println("接收到客戶端的信息是:" + new String(bytes));
                }
                count = 0;
            }
        }
    }
}

客戶端代碼如下：

/**
 * 客戶端（只負責發送消息）
 */
static class ClientSocket {
    public static void main(String[] args) throws IOException {
        // 創建 Socket 客戶端並嘗試連接服務器端
        Socket socket = new Socket("127.0.0.1", 9999);
        // 發送的消息內容
        final String message = "Hi,Java."; 
        // 使用輸出流發送消息
        try (OutputStream outputStream = socket.getOutputStream()) {
            // 給服務器端發送 10 次消息
            for (int i = 0; i < 10; i++) {
                // 發送消息
                outputStream.write(message.getBytes());
            }
        }
    }
}

以上程序的通訊結果如下圖所示：

通過上述結果我們可以看出，服務器端發生了粘包和半包的問題，因為客戶端發送了 10 次固定的「Hi,Java.」的消息，正常的結果應該是服務器端也接收到了 10 次固定的消息才對，但現實的結果並非如此。

粘包和半包的解決方案

粘包和半包的解決方案有以下 3 種：

1. 發送方和接收方規定固定大小的緩衝區，也就是發送和接收都使用固定大小的 byte[] 數組長度，當字符長度不夠時使用空字符彌補；
2. 在 TCP 協議的基礎上封裝一層數據請求協議，既將數據包封裝成數據頭（存儲數據正文大小）+ 數據正文的形式，這樣在服務端就可以知道每個數據包的具體長度了，知道了發送數據的具體邊界之後，就可以解決半包和粘包的問題了；
3. 以特殊的字符結尾，比如以「\n」結尾，這樣我們就知道結束字符，從而避免了半包和粘包問題（推薦解決方案）。

那麼接下來我們就來演示一下，以上解決方案的具體代碼實現。

解決方案1：固定緩衝區大小

固定緩衝區大小的實現方案，只需要控制服務器端和客戶端發送和接收位元組的（數組）長度相同即可。

服務器端實現代碼如下：

/**
 * 服務器端，改進版本一（只負責接收消息）
 */
static class ServSocketV1 {
    private static final int BYTE_LENGTH = 1024;  // 位元組數組長度（收消息用）
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9091);
        // 獲取到連接
        Socket clientSocket = serverSocket.accept();
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                byte[] bytes = new byte[BYTE_LENGTH];
                // 讀取客戶端發送的信息
                int count = inputStream.read(bytes, 0, BYTE_LENGTH);
                if (count > 0) {
                    // 接收到消息打印
                    System.out.println("接收到客戶端的信息是:" + new String(bytes).trim());
                }
                count = 0;
            }
        }
    }
}

客戶端實現代碼如下：

/**
 * 客戶端，改進版一（只負責接收消息）
 */
static class ClientSocketV1 {
    private static final int BYTE_LENGTH = 1024;  // 位元組長度
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 9091);
        final String message = "Hi,Java."; // 發送消息
        try (OutputStream outputStream = socket.getOutputStream()) {
            // 將數據組裝成定長位元組數組
            byte[] bytes = new byte[BYTE_LENGTH];
            int idx = 0;
            for (byte b : message.getBytes()) {
                bytes[idx] = b;
                idx++;
            }
            // 給服務器端發送 10 次消息
            for (int i = 0; i < 10; i++) {
                outputStream.write(bytes, 0, BYTE_LENGTH);
            }
        }
    }
}

以上代碼的執行結果如下圖所示：

優缺點分析

從以上代碼可以看出，雖然這種方式可以解決粘包和半包的問題，但這種固定緩衝區大小的方式增加了不必要的數據傳輸，因為這種方式當發送的數據比較小時會使用空字符來彌補，所以這種方式就大大的增加了網絡傳輸的負擔，所以它也不是最佳的解決方案。

解決方案二：封裝請求協議

這種解決方案的實現思路是將請求的數據封裝為兩部分：數據頭+數據正文，在數據頭中存儲數據正文的大小，當讀取的數據小於數據頭中的大小時，繼續讀取數據，直到讀取的數據長度等於數據頭中的長度時才停止。

因為這種方式可以拿到數據的邊界，所以也不會導致粘包和半包的問題，但這種實現方式的編碼成本較大也不夠優雅，因此不是最佳的實現方案，因此我們這裡就略過，直接來看最終的解決方案吧。

解決方案三：特殊字符結尾，按行讀取

以特殊字符結尾就可以知道流的邊界了，因此也可以用來解決粘包和半包的問題，此實現方案是我們推薦最終解決方案。

這種解決方案的核心是，使用 Java 中自帶的 BufferedReader 和 BufferedWriter，也就是帶緩衝區的輸入字符流和輸出字符流，通過寫入的時候加上 \n 來結尾，讀取的時候使用 readLine 按行來讀取數據，這樣就知道流的邊界了，從而解決了粘包和半包的問題。

服務器端實現代碼如下：

/**
 * 服務器端，改進版三(只負責收消息)
 */
static class ServSocketV3 {
    public static void main(String[] args) throws IOException {
        // 創建 Socket 服務器端
        ServerSocket serverSocket = new ServerSocket(9092);
        // 獲取客戶端連接
        Socket clientSocket = serverSocket.accept();
        // 使用線程池處理更多的客戶端
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
        threadPool.submit(() -> {
            // 消息處理
            processMessage(clientSocket);
        });
    }
    /**
     * 消息處理
     * @param clientSocket
     */
    private static void processMessage(Socket clientSocket) {
        // 獲取客戶端發送的消息流對象
        try (BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()))) {
            while (true) {
                // 按行讀取客戶端發送的消息
                String msg = bufferedReader.readLine();
                if (msg != null) {
                    // 成功接收到客戶端的消息並打印
                    System.out.println("接收到客戶端的信息:" + msg);
                }
            }
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
    }
}

PS：上述代碼使用了線程池來解決多個客戶端同時訪問服務器端的問題，從而實現了一對多的服務器響應。

客戶端的實現代碼如下：

/**
 * 客戶端，改進版三(只負責發送消息)
 */
static class ClientSocketV3 {
    public static void main(String[] args) throws IOException {
        // 啟動 Socket 並嘗試連接服務器
        Socket socket = new Socket("127.0.0.1", 9092);
        final String message = "Hi,Java."; // 發送消息
        try (BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(socket.getOutputStream()))) {
            // 給服務器端發送 10 次消息
            for (int i = 0; i < 10; i++) {
                // 注意:結尾的 \n 不能省略,它表示按行寫入
                bufferedWriter.write(message + "\n");
                // 刷新緩衝區(此步驟不能省略)
                bufferedWriter.flush();
            }
        }
    }
}

以上代碼的執行結果如下圖所示：

總結

本文我們講了 TCP 粘包和半包問題，粘包是指讀取到了兩條信息，正常情況下消息應該是一條一條讀取的，而半包問題是指讀取了一半信息。導致粘包和半包的原因是 TCP 的傳輸是以流的形式進行的，而流數據是沒有明確的開始和結尾標識的，因此就導致了此問題。

本文我們提供了 3 種粘包和半包的解決方案，其中最推薦的是使用 BufferedReader 和 BufferedWriter 按行來讀、寫和區分消息，也就是本文的第三種解決方案。

參考 & 鳴謝

//zhuanlan.zhihu.com/p/126279630

//www.jianshu.com/p/6a4ec6095f2c

關注公眾號「Java中文社群」發現更多乾貨。

查看 Github 發現更多精彩：//github.com/vipstone/algorithm