<s id="0oyqk"></s>
  • <option id="0oyqk"><optgroup id="0oyqk"></optgroup></option>
  • <source id="0oyqk"><bdo id="0oyqk"></bdo></source>
  • Golang TCP粘包拆包問題的解決方法

     更新時間:2019-09-09 09:01:34   作者:佚名   我要評論(0)

    什么是粘包問題


    最近在使用Golang編寫Socket層,發現有時候接收端會一次讀到多個數據包的問題。于是通過查閱資料,發現這個就是傳說中的TCP粘包問題。下面

    什么是粘包問題

    最近在使用Golang編寫Socket層,發現有時候接收端會一次讀到多個數據包的問題。于是通過查閱資料,發現這個就是傳說中的TCP粘包問題。下面通過編寫代碼來重現這個問題:

    服務端代碼 server/main.go

    func main() {
    	l, err := net.Listen("tcp", ":4044")
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println("listen to 4044")
    	for {
      // 監聽到新的連接,創建新的 goroutine 交給 handleConn函數 處理
    		conn, err := l.Accept()
    		if err != nil {
    			fmt.Println("conn err:", err)
    		} else {
    			go handleConn(conn)
    		}
    	}
    }
    
    func handleConn(conn net.Conn) {
    	defer conn.Close()
    	defer fmt.Println("關閉")
    	fmt.Println("新連接:", conn.RemoteAddr())
    
    	result := bytes.NewBuffer(nil)
    	var buf [1024]byte
    	for {
    		n, err := conn.Read(buf[0:])
    		result.Write(buf[0:n])
    		if err != nil {
    			if err == io.EOF {
    				continue
    			} else {
    				fmt.Println("read err:", err)
    				break
    			}
    		} else {
    			fmt.Println("recv:", result.String())
    		}
    		result.Reset()
    	}
    }

    客戶端代碼 client/main.go

    func main() {
    	data := []byte("[這里才是一個完整的數據包]")
    	conn, err := net.DialTimeout("tcp", "localhost:4044", time.Second*30)
    	if err != nil {
    		fmt.Printf("connect failed, err : %v\n", err.Error())
      return
    	}
    	for i := 0; i <1000; i++ {
    		_, err = conn.Write(data)
    		if err != nil {
    			fmt.Printf("write failed , err : %v\n", err)
    			break
    		}
    	}
    }

    運行結果

    listen to 4044
    新連接: [::1]:53079
    recv: [這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據�
    recv: �][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包][這里才是一個完整的數據包][這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    ...省略其它的...

    從服務端的控制臺輸出可以看出,存在三種類型的輸出:

    1. 一種是正常的一個數據包輸出。
    2. 一種是多個數據包“粘”在了一起,我們定義這種讀到的包為粘包。
    3. 一種是一個數據包被“拆”開,形成一個破碎的包,我們定義這種包為半包。

    為什么會出現半包和粘包?

    • 客戶端一段時間內發送包的速度太多,服務端沒有全部處理完。于是數據就會積壓起來,產生粘包。
    • 定義的讀的buffer不夠大,而數據包太大或者由于粘包產生,服務端不能一次全部讀完,產生半包。

    什么時候需要考慮處理半包和粘包?

    TCP連接是長連接,即一次連接多次發送數據。
    每次發送的數據是結構的,比如 JSON格式的數據 或者 數據包的協議是由我們自己定義的(包頭部包含實際數據長度、協議魔數等)。

    解決思路

    1. 定長分隔(每個數據包最大為該長度,不足時使用特殊字符填充) ,但是數據不足時會浪費傳輸資源
    2. 使用特定字符來分割數據包,但是若數據中含有分割字符則會出現Bug
    3. 在數據包中添加長度字段,彌補了以上兩種思路的不足,推薦使用

    拆包演示

    通過上述分析,我們最好通過第三種思路來解決拆包粘包問題。

    Golang的bufio庫中有為我們提供了Scanner,來解決這類分割數據的問題。

    type Scanner
    Scanner provides a convenient interface for reading data such as a file of newline-delimited lines of text. Successive calls to the Scan method will step through the 'tokens' of a file, skipping the bytes between the tokens. The specification of a token is defined by a split function of type SplitFunc; the default split function breaks the input into lines with line termination stripped. Split functions are defined in this package for scanning a file into lines, bytes, UTF-8-encoded runes, and space-delimited words. The client may instead provide a custom split function.

    簡單來講即是:

    Scanner為 讀取數據 提供了方便的 接口。連續調用Scan方法會逐個得到文件的“tokens”,跳過 tokens 之間的字節。token 的規范由 SplitFunc 類型的函數定義。我們可以改為提供自定義拆分功能。

    接下來看看 SplitFunc 類型的函數是什么樣子的:

    type SplitFunc func(data []byte, atEOF bool) (advance int, token []byte, err error)

    Golang官網文檔上提供的使用例子🌰:

    func main() {
    	// An artificial input source.
    	const input = "1234 5678 1234567901234567890"
    	scanner := bufio.NewScanner(strings.NewReader(input))
    	// Create a custom split function by wrapping the existing ScanWords function.
    	split := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
    		advance, token, err = bufio.ScanWords(data, atEOF)
    		if err == nil && token != nil {
    			_, err = strconv.ParseInt(string(token), 10, 32)
    		}
    		return
    	}
    	// Set the split function for the scanning operation.
    	scanner.Split(split)
    	// Validate the input
    	for scanner.Scan() {
    		fmt.Printf("%s\n", scanner.Text())
    	}
    
    	if err := scanner.Err(); err != nil {
    		fmt.Printf("Invalid input: %s", err)
    	}
    }

    于是,我們可以這樣改寫我們的程序:

    服務端代碼 server/main.go

    func main() {
    	l, err := net.Listen("tcp", ":4044")
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println("listen to 4044")
    	for {
    		conn, err := l.Accept()
    		if err != nil {
    			fmt.Println("conn err:", err)
    		} else {
    			go handleConn2(conn)
    		}
    	}
    }
    
    func packetSlitFunc(data []byte, atEOF bool) (advance int, token []byte, err error) {
      // 檢查 atEOF 參數 和 數據包頭部的四個字節是否 為 0x123456(我們定義的協議的魔數)
    	if !atEOF && len(data) > 6 && binary.BigEndian.Uint32(data[:4]) == 0x123456 {
    		var l int16
        // 讀出 數據包中 實際數據 的長度(大小為 0 ~ 2^16)
    		binary.Read(bytes.NewReader(data[4:6]), binary.BigEndian, &l)
    		pl := int(l) + 6
    		if pl <= len(data) {
    			return pl, data[:pl], nil
    		}
    	}
    	return
    }
    
    func handleConn2(conn net.Conn) {
    	defer conn.Close()
    	defer fmt.Println("關閉")
    	fmt.Println("新連接:", conn.RemoteAddr())
    	result := bytes.NewBuffer(nil)
      var buf [65542]byte // 由于 標識數據包長度 的只有兩個字節 故數據包最大為 2^16+4(魔數)+2(長度標識)
    	for {
    		n, err := conn.Read(buf[0:])
    		result.Write(buf[0:n])
    		if err != nil {
    			if err == io.EOF {
    				continue
    			} else {
    				fmt.Println("read err:", err)
    				break
    			}
    		} else {
    			scanner := bufio.NewScanner(result)
    			scanner.Split(packetSlitFunc)
    			for scanner.Scan() {
    				fmt.Println("recv:", string(scanner.Bytes()[6:]))
    			}
    		}
    		result.Reset()
    	}
    }

    客戶端代碼 client/main.go

    func main() {
    	l, err := net.Listen("tcp", ":4044")
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println("listen to 4044")
    	for {
    		conn, err := l.Accept()
    		if err != nil {
    			fmt.Println("conn err:", err)
    		} else {
    			go handleConn2(conn)
    		}
    	}
    }
    
    func packetSlitFunc(data []byte, atEOF bool) (advance int, token []byte, err error) {
      // 檢查 atEOF 參數 和 數據包頭部的四個字節是否 為 0x123456(我們定義的協議的魔數)
    	if !atEOF && len(data) > 6 && binary.BigEndian.Uint32(data[:4]) == 0x123456 {
    		var l int16
        // 讀出 數據包中 實際數據 的長度(大小為 0 ~ 2^16)
    		binary.Read(bytes.NewReader(data[4:6]), binary.BigEndian, &l)
    		pl := int(l) + 6
    		if pl <= len(data) {
    			return pl, data[:pl], nil
    		}
    	}
    	return
    }
    
    func handleConn2(conn net.Conn) {
    	defer conn.Close()
    	defer fmt.Println("關閉")
    	fmt.Println("新連接:", conn.RemoteAddr())
    	result := bytes.NewBuffer(nil)
      var buf [65542]byte // 由于 標識數據包長度 的只有兩個字節 故數據包最大為 2^16+4(魔數)+2(長度標識)
    	for {
    		n, err := conn.Read(buf[0:])
    		result.Write(buf[0:n])
    		if err != nil {
    			if err == io.EOF {
    				continue
    			} else {
    				fmt.Println("read err:", err)
    				break
    			}
    		} else {
    			scanner := bufio.NewScanner(result)
    			scanner.Split(packetSlitFunc)
    			for scanner.Scan() {
    				fmt.Println("recv:", string(scanner.Bytes()[6:]))
    			}
    		}
    		result.Reset()
    	}
    }

    運行結果

    listen to 4044
    新連接: [::1]:55738
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    recv: [這里才是一個完整的數據包]
    ...省略其它的...

    總結

    以上就是這篇文章的全部內容了,希望本文的內容對大家的學習或者工作具有一定的參考學習價值,謝謝大家對腳本之家的支持。

    您可能感興趣的文章:

    • golang之tcp自動重連實現方法
    • 利用Golang實現TCP連接的雙向拷貝詳解
    • 6行代碼快速解決golang TCP粘包問題

    相關文章

    • Golang TCP粘包拆包問題的解決方法

      Golang TCP粘包拆包問題的解決方法

      什么是粘包問題 最近在使用Golang編寫Socket層,發現有時候接收端會一次讀到多個數據包的問題。于是通過查閱資料,發現這個就是傳說中的TCP粘包問題。下面
      2019-09-09
    • 下載golang.org/x包的操作方法

      下載golang.org/x包的操作方法

      golang.org/x包放到了https://github.com/golang/text中,下載時需要先在本地建立golang.org/x的目錄后,再下載。 mkdir -p golang.org/x git clone https://
      2019-09-09
    • Golang 使用http Client下載文件的實現方法

      Golang 使用http Client下載文件的實現方法

      之前使用beego的http庫的時候,有的情況需要下載文件。beego是能實現,但就是有點問題:不支持回調,沒法顯示下載速度,這在日常開發中是不可忍受的。 看了下be
      2019-09-09
    • 基于Go和Gin的環境配置方法

      基于Go和Gin的環境配置方法

      1.官方下載Go版本,安裝相應平臺的程序。 2.配置Go的環境變量: GOROOT:GO安裝路徑,例如GOROOT = D:\Go GOPATH: 項目源碼所在目錄(例如GOPATH = E:\go),
      2019-09-09
    • golang 檢查網絡狀態是否正常的方法

      golang 檢查網絡狀態是否正常的方法

      如下所示: package main import ( "fmt" "os/exec" "time" ) func NetWorkStatus() bool { cmd := exec.Command("ping", "baidu.com", "-c", "1", "
      2019-09-09
    • gorm golang 并發連接數據庫報錯的解決方法

      gorm golang 并發連接數據庫報錯的解決方法

      底層報錯 error:cannot assign requested address 原因 并發場景下 client 頻繁請求端口建立tcp連接導致端口被耗盡 解決方案 root執行即可 sysctl -w net.
      2019-09-09
    • golang socket斷點續傳大文件的實現方法

      golang socket斷點續傳大文件的實現方法

      在日常編程中,我們肯定會遇到用socket傳送文件內容,如果是大文件的,總不能傳送到一半因某原因斷掉了,又從新傳送文件內容吧。對,我們需要續傳,也就是接著
      2019-09-09
    • golang http連接復用方法

      golang http連接復用方法

      server端 golang httpserver 默認開啟keepalive連接復用選項 handler函數需要完整讀body數據,構造返回消息,否則當數據不能一次發送完成時,連接復用就會失效
      2019-09-09
    • 詳解golang 模板(template)的常用基本語法

      詳解golang 模板(template)的常用基本語法

      模板 在寫動態頁面的網站的時候,我們常常將不變的部分提出成為模板,可變部分通過后端程序的渲染來生成動態網頁,golang提供了html/template包來支持模板
      2019-09-09
    • golang并發下載多個文件的方法

      golang并發下載多個文件的方法

      背景說明 假設有一個分布式文件系統,現需要從該系統中并發下載一部分文件到本地機器。 已知該文件系統的部分節點ip, 以及需要下載的文件fileID列表,并能通過
      2019-09-09

    最新評論

    种子磁力搜索器