天天看點
傳回

面試突擊70：什麼是粘包和半包？怎麼解決？

粘包和半包問題是資料傳輸中比較常見的問題，所謂的粘包問題是指資料在傳輸時，在一條消息中讀取到了另一條消息的部分資料，這種現象就叫做粘包。 比如發送了兩條消息，分别為“ABC”和“DEF”，那麼正常情況下接收端也應該收到兩條消息“ABC”和“DEF”，但接收端卻收到的是“ABCD”，像這種情況就叫做粘包，如下圖所示：

半包問題是指接收端隻收到了部分資料，而非完整的資料的情況就叫做半包。比如發送了一條消息是“ABC”，而接收端卻收到的是“AB”和“C”兩條資訊，這種情況就叫做半包，如下圖所示：

PS：大部分情況下我們都把粘包問題和半包問題看成同一個問題，是以下文就用“粘包”問題來替代“粘包”和“半包”問題。

1.為什麼會有粘包問題？

粘包問題發生在 TCP/IP 協定中，因為 TCP 是面向連接配接的傳輸協定，它是以“流”的形式傳輸資料的，而“流”資料是沒有明确的開始和結尾邊界的，是以就會出現粘包問題。

2.粘包問題代碼示範

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

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

然後通過列印伺服器端接收到的資訊來觀察粘包問題。

伺服器端代碼實作如下：

/**
 * 伺服器端（隻負責接收消息）
 */
class ServSocket {
    // 位元組數組的長度
    private static final int BYTE_LENGTH = 20;  
    public static void main(String[] args) throws IOException {
        // 建立 Socket 伺服器
        ServerSocket serverSocket = new ServerSocket(8888);
        // 擷取用戶端連接配接
        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", 8888);
        // 發送的消息内容
        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 次固定消息“Hi,Java.”才對，但實際執行結果并非如此。

3.解決方案

粘包問題的常見解決方案有以下 3 種：

  1. 發送方和接收方固定發送資料的大小，當字元長度不夠時用空字元彌補，有了固定大小之後就知道每條消息的具體邊界了，這樣就沒有粘包的問題了；
  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);
         }
     }
 }
}
    以上代碼的執行結果如下圖所示：

    優缺點分析

    從以上代碼可以看出，雖然這種方式可以解決粘包問題，但這種固定資料大小的傳輸方式，當資料量比較小時會使用空字元來填充，是以會額外的增加網絡傳輸的負擔，是以不是理想的解決方案。

    解決方案2：自定義請求協定

    這種解決方案的實作思路是将請求的資料封裝為兩部分：消息頭（發送的資料大小）+消息體（發送的具體資料），它的格式如下圖所示：

    此解決方案的實作分為以下 3 部分：

  4. 編寫一個消息封裝類
  5. 編寫用戶端
  6. 編寫伺服器端

接下來我們一一來實作。

① 消息封裝類

消息的封裝類中提供了兩個方法：一個是将消息轉換成消息頭 + 消息體的方法，另一個是讀取消息頭的方法，具體實作代碼如下：

/**
 * 消息封裝類
 */
class SocketPacket {
    // 消息頭存儲的長度(占 8 位元組)
    static final int HEAD_SIZE = 8;

    /**
     * 将協定封裝為:協定頭 + 協定體
     * @param context 消息體(String 類型)
     * @return byte[]
     */
    public byte[] toBytes(String context) {
        // 協定體 byte 數組
        byte[] bodyByte = context.getBytes();
        int bodyByteLength = bodyByte.length;
        // 最終封裝對象
        byte[] result = new byte[HEAD_SIZE + bodyByteLength];
        // 借助 NumberFormat 将 int 轉換為 byte[]
        NumberFormat numberFormat = NumberFormat.getNumberInstance();
        numberFormat.setMinimumIntegerDigits(HEAD_SIZE);
        numberFormat.setGroupingUsed(false);
        // 協定頭 byte 數組
        byte[] headByte = numberFormat.format(bodyByteLength).getBytes();
        // 封裝協定頭
        System.arraycopy(headByte, 0, result, 0, HEAD_SIZE);
        // 封裝協定體
        System.arraycopy(bodyByte, 0, result, HEAD_SIZE, bodyByteLength);
        return result;
    }

    /**
     * 擷取消息頭的内容(也就是消息體的長度)
     * @param inputStream
     * @return
     */
    public int getHeader(InputStream inputStream) throws IOException {
        int result = 0;
        byte[] bytes = new byte[HEAD_SIZE];
        inputStream.read(bytes, 0, HEAD_SIZE);
        // 得到消息體的位元組長度
        result = Integer.valueOf(new String(bytes));
        return result;
    }
}

② 用戶端

用戶端中我們添加一組待發送的消息，随機給伺服器端發送一個消息，實作代碼如下：

/**
 * 用戶端
 */
class MySocketClient {
    public static void main(String[] args) throws IOException {
        // 啟動 Socket 并嘗試連接配接伺服器
        Socket socket = new Socket("127.0.0.1", 9093);
        // 發送消息合集（随機發送一條消息）
        final String[] message = {"Hi,Java.", "Hi,SQL~", "關注公衆号|Java中文社群."};
        // 建立協定封裝對象
        SocketPacket socketPacket = new SocketPacket();
        try (OutputStream outputStream = socket.getOutputStream()) {
            // 給伺服器端發送 10 次消息
            for (int i = 0; i < 10; i++) {
                // 随機發送一條消息
                String msg = message[new Random().nextInt(message.length)];
                // 将内容封裝為:協定頭+協定體
                byte[] bytes = socketPacket.toBytes(msg);
                // 發送消息
                outputStream.write(bytes, 0, bytes.length);
                outputStream.flush();
            }
        }
    }
}

③ 伺服器端

伺服器端使用線程池來處理每個用戶端的業務請求，實作代碼如下：

/**
 * 伺服器端
 */
class MySocketServer {
    public static void main(String[] args) throws IOException {
        // 建立 Socket 伺服器端
        ServerSocket serverSocket = new ServerSocket(9093);
        // 擷取用戶端連接配接
        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) {
        // Socket 封裝對象
        SocketPacket socketPacket = new SocketPacket();
        // 擷取用戶端發送的消息對象
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                // 擷取消息頭(也就是消息體的長度)
                int bodyLength = socketPacket.getHeader(inputStream);
                // 消息體 byte 數組
                byte[] bodyByte = new byte[bodyLength];
                // 每次實際讀取位元組數
                int readCount = 0;
                // 消息體指派下标
                int bodyIndex = 0;
                // 循環接收消息頭中定義的長度
                while (bodyIndex <= (bodyLength - 1) &&
                        (readCount = inputStream.read(bodyByte, bodyIndex, bodyLength)) != -1) {
                    bodyIndex += readCount;
                }
                bodyIndex = 0;
                // 成功接收到用戶端的消息并列印
                System.out.println("接收到用戶端的資訊:" + new String(bodyByte));
            }
        } catch (IOException ioException) {
            System.out.println(ioException.getMessage());
        }
    }
}

以上程式的執行結果如下：

從上述結果可以看出，消息通訊正常，用戶端和伺服器端的互動中并沒有出現粘包問題。

優缺點分析

此解決方案雖然可以解決粘包問題，但消息的設計和代碼的實作複雜度比較高，是以也不是理想的解決方案。

解決方案3：特殊字元結尾

以特殊字元結尾就可以知道流的邊界了，它的具體實作是：使用 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();
            }
        }
    }
}

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

優缺點分析

以特殊符号作為粘包的解決方案的最大優點是實作簡單，但存在一定的局限性，比如當一條消息中間如果出現了結束符就會造成半包的問題，是以如果是複雜的字元串要對内容進行編碼和解碼處理，這樣才能保證結束符的正确性。

總結

粘包和半包問題是資料傳輸中比較常見的問題，它的解決方案有很多，比較常見的解決方案有：設定固定的資料傳輸大小、自定義請求協定的封裝，在請求頭中加入傳輸資料的長度、使用特殊符号作為結束符等。

是非審之于己，毀譽聽之于人，得失安之于數。

公衆号：Java面試真題解析

面試合集：https://gitee.com/mydb/interview

關注下面二維碼，訂閱更多精彩内容。

關注公衆号（加好友）：

面試突擊70：什麼是粘包和半包？怎麼解決？

作者：

王磊的部落格

出處：

http://vipstone.cnblogs.com/

上一篇: 國産崛起，任正非預言成真！華為正“向上捅破天，向下紮到根”曾幾何時，當中國制造被無端封鎖，晶片規則被肆意篡改之時，任正非
下一篇: 面試突擊69：TCP 可靠嗎？為什麼？