Socket粘包問題的3種解決方案，哪一種更優秀！
本文轉載自微信公眾號「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 種：
- 發送方和接收方規定固定大小的緩沖區，也就是發送和接收都使用固定大小的 byte[] 數組長度，當字符長度不夠時使用空字符彌補;
- 在 TCP 協議的基礎上封裝一層數據請求協議，既將數據包封裝成數據頭(存儲數據正文大小)+ 數據正文的形式，這樣在服務端就可以知道每個數據包的具體長度了，知道了發送數據的具體邊界之后，就可以解決半包和粘包的問題了;
- 以特殊的字符結尾，比如以“\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 按行來讀、寫和區分消息，也就是本文的第三種解決方案。
