c#解決TCP「粘包」問題

一：TCP粘包產生的原理

1，TCP粘包是指發送方發送的若干包數據到接收方接收時粘成一包，從接收緩衝區看，後一包數據的頭緊接着前一包數據的尾。出現粘包現象的緣由是多方面的，它既可能由發送方形成，也可能由接收方形成。

2，發送方引發的粘包是由TCP協議自己形成的，TCP爲提升傳輸效率，發送方每每要收集到足夠多的數據後才發送一包數據。若連續幾回發送的數據都不多，一般TCP會根據優化算法把這些數據合成一包後一次發送出去，這樣接收方就收到了粘包數據。接收方引發的粘包是因爲接收方用戶進程不及時接收數據，從而致使粘包現象。

3，這是由於接收方先把收到的數據放在系統接收緩衝區，用戶進程從該緩衝區取數據，若下一包數據到達時前一包數據還沒有被用戶進程取走，則下一包數據放到系統接收緩衝區時就接到前一包數據以後，而用戶進程根據預先設定的緩衝區大小從系統接收緩衝區取數據，這樣就一次取到了多包數據。

二：組件化解決粘包

經過第三方的組件處理這個問題比較方便和快捷，好比國產開源的HP-SOCKET等。

HP-SOCKET官方地址

HP-Socket 是一套通用的高性能 TCP/UDP/HTTP 通訊框架，包含服務端組件、客戶端組件和Agent組件，普遍適用於各類不一樣應用場景的 TCP/UDP/HTTP 通訊系統，提供 C/C++、C#、Delphi、E（易語言）、Java、Python 等編程語言接口。HP-Socket 對通訊層實現徹底封裝，應用程序沒必要關注通訊層的任何細節；HP-Socket 提供基於事件通知模型的 API 接口，能很是簡單高效地整合到新舊應用程序中。

爲了讓使用者能方便快速地學習和使用 HP-Socket ，迅速掌握框架的設計思想和使用方法，特此精心製做了大量 Demo 示例（如：PUSH 模型示例、PULL 模型示例、PACK 模型示例、性能測試示例以及其它編程語言示例）。HP-Socket 目前支持 Windows 和 Linux 平臺。

HP-Socket 的設計充分注重功能、通用型、易用性與伸縮性：

通用性

• HP-Socket 的惟一職責就是接收和發送字節流，不參與應用程序的協議解析等工做。

• HP-Socket 與應用程序經過接口進行交互，並徹底解耦。任何應用只要實現了HP-Socket的接口規範均可以無縫整合 HP-Socket。

易用性

• 易用性對全部通用框架都是相當重要的，若是太難用還不如本身重頭寫一個來得方便。所以，HP-Socket 的接口設計得很是簡單和統一。

• HP-Socket 徹底封裝了全部底層通訊細節，應用程序沒必要也不能干預底層通訊操做。通訊鏈接被抽象爲Connection ID，Connection ID 做爲鏈接的惟一標識提供給應用程序來處理不一樣的鏈接。

• HP-Socket 提供 PUSH / PULL / PACK 等接收模型， 應用程序能夠靈活選擇以手工方式、 半自動方式或全自動方式處理封解包， PULL / PACK 接收模型在下降封解包處理複雜度的同時能大大減小出錯概率。

高性能

• Server 組件：基於IOCP / EPOLL通訊模型，並結合緩存池、私有堆等技術實現高效內存管理，支持超大規模、高併發通訊場景。

• Agent 組件：Agent組件實質上是Multi-Client組件，與Server組件採用相同的技術架構。一個Agent組件對象可同時創建和高效處理大規模Socket鏈接。

• Client 組件：基於Event Select / POLL通訊模型，每一個組件對象建立一個通訊線程並管理一個Socket鏈接，適用於小規模客戶端場景。

伸縮性

      應用程序可以根據不一樣的容量要求、通訊規模和資源情況等現實場景調整 HP-Socket 的各項性能參數（如：工做線程的數量、緩存池的大小、發送模式和接收模式等），優化資源配置，在知足應用需求的同時沒必要過分浪費資源。

三：解決原理及代碼實現

1，採用包頭（固定長度，裏面存着包體的長度，發送時動態獲取）+包體的傳輸機制。如圖

HeaderSize 存放着包體的長度，其HeaderSize自己是定長4字節；

一個完整的數據包（L）=HeaderSize+BodySize;

2，分包算法

　　其基本思路是首先將待處理的接收數據流即系統緩衝區數據（長度設爲M）強行轉換成預約的結構數據形式，並從中取出結構數據長度字段L，然後根據包頭計算獲得第一包數據長度。

       M=系統緩衝區大小；L=用戶發送的數據包=HeaderSize+BodySize;

　　1)若L<M，則代表數據流包含多包數據，從其頭部截取若干個字節存入臨時緩衝區，剩餘部分數據依此繼續循環處理，直至結束。

     

　　2)若L=M，則代表數據流內容剛好是一完整結構數據（即用戶自定義緩衝區等於系統接收緩衝區大小），直接將其存入臨時緩衝區便可。

      

　　3)若L>M，則代表數據流內容尚不夠構成一完整結構數據，需留待與下一包數據合併後再行處理。

        

      4）下面是代碼代碼實現（HP-SOCKET框架的服務器端來接收數據）

int headSize = 4;//包頭長度 固定4
        byte[] surplusBuffer = null;//不完整的數據包，即用戶自定義緩衝區
        /// <summary>
        /// 接收客戶端發來的數據
        /// </summary>
        /// <param name="connId">每一個客戶的會話ID</param>
        /// <param name="bytes">緩衝區數據</param>
        /// <returns></returns>
        private HandleResult OnReceive(IntPtr connId, byte[] bytes) 
        {
            //bytes 爲系統緩衝區數據
            //bytesRead爲系統緩衝區長度
            int bytesRead = bytes.Length;
            if (bytesRead > 0)
            {
                if (surplusBuffer == null)//判斷是否是第一次接收，爲空說是第一次
                    surplusBuffer = bytes;//把系統緩衝區數據放在自定義緩衝區裏面
                else
                    surplusBuffer = surplusBuffer.Concat(bytes).ToArray();//拼接上一次剩餘的包
                //已經完成讀取每一個數據包長度
                int haveRead = 0;
                //這裏totalLen的長度有可能大於緩衝區大小的(由於 這裏的surplusBuffer 是系統緩衝區+不完整的數據包)
                int totalLen = surplusBuffer.Length;
                while (haveRead <= totalLen)
                {
                    //若是在N此拆解後剩餘的數據包連一個包頭的長度都不夠
                    //說明是上次讀取N個完整數據包後，剩下的最後一個非完整的數據包
                    if (totalLen - haveRead < headSize)
                    {
                        byte[] byteSub = new byte[totalLen - haveRead];
                        //把剩下不夠一個完整的數據包存起來
                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                        surplusBuffer = byteSub;
                        totalLen = 0;
                        break;
                    }
                    //若是夠了一個完整包，則讀取包頭的數據
                    byte[] headByte = new byte[headSize];
                    Buffer.BlockCopy(surplusBuffer, haveRead, headByte, 0, headSize);//從緩衝區裏讀取包頭的字節
                    int bodySize = BitConverter.ToInt32(headByte, 0);//從包頭裏面分析出包體的長度

                    //這裏的 haveRead=等於N個數據包的長度 從0開始；0,1,2,3....N
                    //若是自定義緩衝區拆解N個包後的長度 大於 總長度，說最後一段數據不夠一個完整的包了，拆出來保存
                    if (haveRead + headSize + bodySize > totalLen)
                    {
                        byte[] byteSub = new byte[totalLen - haveRead];
                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                        surplusBuffer = byteSub;
                        break;
                    }
                    else
                    {
                        //挨個分解每一個包，解析成實際文字
                        String strc = Encoding.UTF8.GetString(surplusBuffer, haveRead + headSize, bodySize);
                        //AddMsg(string.Format(" > [OnReceive] -> {0}", strc));
                        //依次累加當前的數據包的長度
                        haveRead = haveRead + headSize + bodySize;
                        if (headSize + bodySize == bytesRead)//若是當前接收的數據包長度正好等於緩衝區長度，則待拼接的不規則數據長度歸0
                        {
                            surplusBuffer = null;//設置空 回到原始狀態
                            totalLen = 0;//清0
                        }
                    }
                }
            }
            return HandleResult.Ok;
        }

 

值此完成拆包解析文字工做。但實際上還沒完成，若是這段代碼是客戶端接收來自服務器的數據的話就沒問題了。

仔細看IntPtr connId 每一個鏈接的會話ID

private HandleResult OnReceive(IntPtr connId, byte[] bytes)

{

}

可是服務器端還要分辨出 每一個數據包是哪一個會話產生的，由於服務器端是多線程，多用戶的模式，第一個數據包和第二個可能來自不一樣會話的數據，因此上面的代碼只適用於單會話模式。

下面我要解決這個問題。

採用c#安全的ConcurrentDictionary，具體參考 https://msdn.microsoft.com/zh-cn/library/dd287191(v=vs.110).aspx

最新的代碼

 

　　　　　//線程安全的字典
        ConcurrentDictionary<IntPtr, byte[]> dic = new ConcurrentDictionary<IntPtr, byte[]>();
        int headSize = 4;//包頭長度 固定4
        /// <summary>
        /// 接收客戶端發來的數據
        /// </summary>
        /// <param name="connId">每一個客戶的會話ID</param>
        /// <param name="bytes">緩衝區數據</param>
        /// <returns></returns>
        private HandleResult OnReceive(IntPtr connId, byte[] bytes) 
        {
            //bytes 爲系統緩衝區數據
            //bytesRead爲系統緩衝區長度
            int bytesRead = bytes.Length;
            if (bytesRead > 0)
            {
                byte[] surplusBuffer = null;
                if (dic.TryGetValue(connId, out surplusBuffer))
                {
                    byte[] curBuffer = surplusBuffer.Concat(bytes).ToArray();//拼接上一次剩餘的包
                    //更新會話ID 的最新字節
                    dic.TryUpdate(connId, curBuffer, surplusBuffer);
                    surplusBuffer = curBuffer;//同步
                }
                else
                {
                    //添加會話ID的bytes
                    dic.TryAdd(connId, bytes);
                    surplusBuffer = bytes;//同步
                }

                //已經完成讀取每一個數據包長度
                int haveRead = 0;
                //這裏totalLen的長度有可能大於緩衝區大小的(由於 這裏的surplusBuffer 是系統緩衝區+不完整的數據包)
                int totalLen = surplusBuffer.Length;
                while (haveRead <= totalLen)
                {
                    //若是在N此拆解後剩餘的數據包連一個包頭的長度都不夠
                    //說明是上次讀取N個完整數據包後，剩下的最後一個非完整的數據包
                    if (totalLen - haveRead < headSize)
                    {
                        byte[] byteSub = new byte[totalLen - haveRead];
                        //把剩下不夠一個完整的數據包存起來
                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                        dic.TryUpdate(connId, byteSub, surplusBuffer);
                        surplusBuffer = byteSub;
                        totalLen = 0;
                        break;
                    }
                    //若是夠了一個完整包，則讀取包頭的數據
                    byte[] headByte = new byte[headSize];
                    Buffer.BlockCopy(surplusBuffer, haveRead, headByte, 0, headSize);//從緩衝區裏讀取包頭的字節
                    int bodySize = BitConverter.ToInt32(headByte, 0);//從包頭裏面分析出包體的長度

                    //這裏的 haveRead=等於N個數據包的長度 從0開始；0,1,2,3....N
                    //若是自定義緩衝區拆解N個包後的長度 大於 總長度，說最後一段數據不夠一個完整的包了，拆出來保存
                    if (haveRead + headSize + bodySize > totalLen)
                    {
                        byte[] byteSub = new byte[totalLen - haveRead];
                        Buffer.BlockCopy(surplusBuffer, haveRead, byteSub, 0, totalLen - haveRead);
                        dic.TryUpdate(connId, byteSub, surplusBuffer);
                        surplusBuffer = byteSub;
                        break;
                    }
                    else
                    {
                        //挨個分解每一個包，解析成實際文字
                        String strc = Encoding.UTF8.GetString(surplusBuffer, haveRead + headSize, bodySize);
                        AddMsg(string.Format(" > {0}[OnReceive] -> {1}", connId, strc));
                        //依次累加當前的數據包的長度
                        haveRead = haveRead + headSize + bodySize;
                        
　　　　　　　　　　　　　　//若是當前接收的數據包長度正好等於緩衝區長度，則待拼接的不規則數據長度歸0
　　　　　　　　　　　　　　if (headSize + bodySize == bytesRead)
                        {
                            byte[] xbtye=null;
                            dic.TryRemove(connId, out xbtye);
                            surplusBuffer = null;//設置空 回到原始狀態
                            totalLen = 0;//清0
                        }
                    }
                }
            }
            return HandleResult.Ok;
        }

這樣就解決了，多客戶端會話形成的接收混亂。至此全部工做完成。以上代碼就是爲了參考學習，若是實在不想這麼麻煩。能夠直接使用HP-SOCKET通訊框架的PACK模型，裏面自動實現瞭解決粘包的問題。