Go語言Append缺陷引發(fā)的深度拷貝討論
看完蘇炳添進(jìn)入總決賽，看得我熱血沸騰的，上廁所都不敢耽擱超過 5 分鐘。
這歷史性的一刻，讓本決定休息的我，垂死病中驚坐起，開始肝文章。
- 引子
- 何謂淺?何謂深?
- 深拷貝的四種方式
- 手寫拷貝函數(shù)
- json序列化反序列化
- gob序列化反序列化
- 基準(zhǔn)測試(性能測試)
- 小結(jié)
引子
今天的文章從我周六加班改的一個bug引入，上下文是在某個struct中有個Labels切片，在組裝數(shù)據(jù)的時候需要為其加上配置變量中的標(biāo)簽。
大家看看會出現(xiàn)什么問題。
- for i := range m{
- m[i].Labels = append(r.Config.Relabel, m[i].Labels...)
- ...
- }
debug發(fā)現(xiàn)，i=0時正常，但第二次乃至第n次會不斷變更之前m[?].Labels的內(nèi)容。
看了append的源碼，原來當(dāng)容量足夠的時候，append會把數(shù)據(jù)直接添加到第一個參數(shù)的切片里。
改為如下代碼，調(diào)換下了位置，一切正常了。
- m[i].Labels = append(m[i].Labels,r.Config.Relabel...)
這是一個隱含的陷阱，在 go 語言中賦值拷貝往往都是淺拷貝，開發(fā)者很容易不小心忽視這一點，導(dǎo)致這種無法預(yù)料的問題出現(xiàn)，以后要多多注意了。
借由這個問題以及上一篇文章的作業(yè)中，提到的深度拷貝問題展開今天的文章。
何謂淺?何謂深?
我多年以前是做c++的，它的對象拷貝是淺拷貝，原理是調(diào)用了默認(rèn)的拷貝構(gòu)造函數(shù)，需要人為的重寫，進(jìn)行拷貝的過程，特別是指針需要謹(jǐn)慎的生成的釋放，來避免內(nèi)存泄露的發(fā)生。
后來接觸了Python 發(fā)現(xiàn)深淺拷貝的問題在后端語言中都是存在的，Go 也不例外。
淺拷貝對于值類型是完全拷貝一份，而對于引用類型是拷貝其地址。也就是拷貝的對象修改引用類型的變量同樣會影響到源對象。
這就是為什么channel在做參數(shù)傳遞的時候，向內(nèi)部寫入內(nèi)容，接收端可以成功收到的原因。
在Go中，指針、slice、channel、interface、map、函數(shù)都是淺拷貝。最容易出問題的就是指針、切片、map這三種類型。
方便的點是作為參數(shù)傳遞不需要取地址可以直接修改其內(nèi)容，只要函數(shù)內(nèi)部不出現(xiàn)覆蓋就不需要返回值。
但作為結(jié)構(gòu)體中的成員變量，在拷貝結(jié)構(gòu)體后問題就暴露出來了。修改一處導(dǎo)致另一處也變了。
深拷貝的四種方式
有一次和女朋友聊到深拷貝的問題，她告訴我最方便的深拷貝方法就是序列化為json再反序列化。
我聽到這種方案，頓時驚為天人，確實挺省事的，但由于序列化會用到反射，效率自然不會太高。
深拷貝有四種方式
- 1、手寫拷貝函數(shù)
- 2、json序列化反序列化
- 3、gob序列化反序列化
- 4、使用反射
github上的開源庫，大多基于 1、4 兩種方式做的優(yōu)化。這里的反射方法后面再做討論。
我的github https://github.com/minibear2333/ 后續(xù)會專門寫一個組件，提供深度拷貝的各種現(xiàn)成的方式。
手寫拷貝函數(shù)
定義一個包含切片、字典、指針的結(jié)構(gòu)體。
- type Foo struct {
- List []int
- FooMap map[string]string
- intPtr *int
- }
手動拷貝函數(shù)，把它取名為Duplicate
- func (f *Foo) Duplicate() Foo {
- var tmp = Foo{
- List: make([]int, 0, len(f.List)),
- FooMap: make(map[string]string),
- intPtr: new(int),
- }
- copy(tmp.List, f.List)
- for i := range f.FooMap {
- tmp.FooMap[i] = f.FooMap[i]
- }
- if f.intPtr != nil {
- *tmp.intPtr = *f.intPtr
- } else {
- tmp.intPtr = nil
- }
- return tmp
- }
- 函數(shù)內(nèi)部初始化結(jié)構(gòu)體
- copy是標(biāo)準(zhǔn)庫自帶的拷貝函數(shù)
- map只能range來拷貝，這里map為nil不會報錯
- 指針使用前必須判空，為指針的指向賦值，而不能覆蓋指針地址
測試
- func main() {
- var a = 1
- var t1 = Foo{intPtr: &a}
- t2 := t1.Duplicate()
- a = 2
- fmt.Println(*t1.intPtr)
- fmt.Println(*t2.intPtr)
- }
輸出說明深拷貝成功
- 2
- 1
json序列化反序列化
這種方式完成深度拷貝非常簡單，但必須結(jié)構(gòu)體加上注解，而且不允許出現(xiàn)私有字段
- type Foo struct {
- List []int `json:"list"`
- FooMap map[string]string `json:"foo_map"`
- IntPtr *int `json:"int_ptr"`
- }
提供一個直接的方案
- func DeepCopyByJson(dst, src interface{}) error {
- b, err := json.Marshal(src)
- if err != nil {
- return err
- }
- err = json.Unmarshal(b, dst)
- return err
- }
- 其中src和dst是同一種結(jié)構(gòu)體類型
- dst使用時必須取地址，因為要給地址指向的數(shù)據(jù)變更新值
用法，我省略了錯誤處理
- a = 3
- t1 = Foo{IntPtr: &a}
- t2 = Foo{}
- _ = DeepCopyByJson(&t2, t1)
- fmt.Println(*t1.IntPtr)
- fmt.Println(*t2.IntPtr)
輸出
- 3
- 3
gob序列化反序列化
這是一種標(biāo)準(zhǔn)庫提供的編碼方法，類似于protobuf，Gob(即 Go binary 的縮寫)。類似于 Python 的pickle和 Java 的Serialization。
在發(fā)送端編碼，接收端解碼。
- func DeepCopyByGob(dst, src interface{}) error {
- var buffer bytes.Buffer
- if err := gob.NewEncoder(&buffer).Encode(src); err != nil {
- return err
- }
- return gob.NewDecoder(&buffer).Decode(dst)
- }
用法
- func DeepCopyByGob(dst, src interface{}) error {
- var buffer bytes.Buffer
- if err := gob.NewEncoder(&buffer).Encode(src); err != nil {
- return err
- }
- return gob.NewDecoder(&buffer).Decode(dst)
- }
輸出
- 4
- 4
基準(zhǔn)測試(性能測試)
這三種方式我分別寫了基準(zhǔn)測試的測試用例，go會自動反復(fù)調(diào)用，直到測算出一個合理的時間范圍。
基準(zhǔn)測試代碼，這里僅寫一個，其他兩個函數(shù)的測試方式類似：
- func BenchmarkDeepCopyByJson(b *testing.B) {
- b.StopTimer()
- var a = 1
- var t1 = Foo{IntPtr: &a}
- t2 := Foo{}
- b.StartTimer()
- for i := 0; i < b.N; i++ {
- _ = DeepCopyByJson(&t2, t1)
- }
- }
運行測試
- $ go test -test.bench=. -cpu=1,16 -benchtime=2s
- goos: darwin
- goarch: amd64
- pkg: my_copy
- cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
- BenchmarkFoo_Duplicate 35887767 62.64 ns/op
- BenchmarkFoo_Duplicate-16 37554250 62.56 ns/op
- BenchmarkDeepCopyByGob 104292 22941 ns/op
- BenchmarkDeepCopyByGob-16 103060 23049 ns/op
- BenchmarkDeepCopyByJson 2052482 1171 ns/op
- BenchmarkDeepCopyByJson-16 2057090 1175 ns/op
- PASS
- ok my_copy 17.166s
- 在mac環(huán)境下單核和多核并沒有明顯差異
- 運行速度快慢，手動拷貝方式 > json > gob
- 拷貝方式都相差了 2 個數(shù)量級
小結(jié)
如果是偶爾使用的程序可以使用json序列化反序列化的方式進(jìn)行拷貝，但是除了慢以外還有一個缺陷，就是無法拷貝私有成員變量。
如果是頻繁拷貝的程序，建議使用手動拷貝方式進(jìn)行拷貝，而且可以定制化拷貝的過程。甚至可以完成不同結(jié)構(gòu)體之間，字段細(xì)微差異的定制化需求。
PS：內(nèi)置copy和reflect.copy都只支持切片或數(shù)組的拷貝，內(nèi)置copy速度是反射方式的兩倍以上。
拓展資料
- Go 語言使用 Gob 傳輸數(shù)據(jù) http://c.biancheng.net/view/4597.html)
- 內(nèi)建copy函數(shù)和reflect.Copy函數(shù)的區(qū)別 https://studygolang.com/topics/13523/comment/43357
- 基準(zhǔn)測試 https://segmentfault.com/a/1190000016354758
本文轉(zhuǎn)載自微信公眾號「機智的程序員小熊」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系機智的程序員小熊公眾號。
