[[414910]]

看完蘇炳添進入總決賽，看得我熱血沸騰的，上廁所都不敢耽擱超過 5 分鐘。

這歷史性的一刻，讓本決定休息的我，垂死病中驚坐起，開始肝文章。

• 引子
• 何謂淺?何謂深?
• 深拷貝的四種方式
• 手寫拷貝函數
• json序列化反序列化
• gob序列化反序列化
• 基準測試(性能測試)
• 小結

引子

今天的文章從我周六加班改的一個bug引入，上下文是在某個struct中有個Labels切片，在組裝數據的時候需要為其加上配置變量中的標簽。

大家看看會出現什么問題。

for i := range m{ 
    m[i].Labels = append(r.Config.Relabel, m[i].Labels...) 
    ... 
} 

debug發現，i=0時正常，但第二次乃至第n次會不斷變更之前m[?].Labels的內容。

看了append的源碼，原來當容量足夠的時候，append會把數據直接添加到第一個參數的切片里。

改為如下代碼，調換下了位置，一切正常了。

m[i].Labels = append(m[i].Labels,r.Config.Relabel...) 

這是一個隱含的陷阱，在 go 語言中賦值拷貝往往都是淺拷貝，開發者很容易不小心忽視這一點，導致這種無法預料的問題出現，以后要多多注意了。

借由這個問題以及上一篇文章的作業中，提到的深度拷貝問題展開今天的文章。

何謂淺?何謂深?

我多年以前是做c++的，它的對象拷貝是淺拷貝，原理是調用了默認的拷貝構造函數，需要人為的重寫，進行拷貝的過程，特別是指針需要謹慎的生成的釋放，來避免內存泄露的發生。

后來接觸了Python 發現深淺拷貝的問題在后端語言中都是存在的，Go 也不例外。

淺拷貝對于值類型是完全拷貝一份，而對于引用類型是拷貝其地址。也就是拷貝的對象修改引用類型的變量同樣會影響到源對象。

這就是為什么channel在做參數傳遞的時候，向內部寫入內容，接收端可以成功收到的原因。

在Go中，指針、slice、channel、interface、map、函數都是淺拷貝。最容易出問題的就是指針、切片、map這三種類型。

方便的點是作為參數傳遞不需要取地址可以直接修改其內容，只要函數內部不出現覆蓋就不需要返回值。

但作為結構體中的成員變量，在拷貝結構體后問題就暴露出來了。修改一處導致另一處也變了。

深拷貝的四種方式

有一次和女朋友聊到深拷貝的問題，她告訴我最方便的深拷貝方法就是序列化為json再反序列化。

我聽到這種方案，頓時驚為天人，確實挺省事的，但由于序列化會用到反射，效率自然不會太高。

深拷貝有四種方式

• 1、手寫拷貝函數
• 2、json序列化反序列化
• 3、gob序列化反序列化
• 4、使用反射

github上的開源庫，大多基于 1、4 兩種方式做的優化。這里的反射方法后面再做討論。

我的github https://github.com/minibear2333/ 后續會專門寫一個組件，提供深度拷貝的各種現成的方式。

手寫拷貝函數

定義一個包含切片、字典、指針的結構體。

type Foo struct { 
 List   []int 
 FooMap map[string]string 
 intPtr *int 
} 

手動拷貝函數，把它取名為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 
} 

• 函數內部初始化結構體
• copy是標準庫自帶的拷貝函數
• 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序列化反序列化

這種方式完成深度拷貝非常簡單，但必須結構體加上注解，而且不允許出現私有字段

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是同一種結構體類型
• dst使用時必須取地址，因為要給地址指向的數據變更新值

用法，我省略了錯誤處理

a = 3 
t1 = Foo{IntPtr: &a} 
t2 = Foo{} 
_ = DeepCopyByJson(&t2, t1) 
fmt.Println(*t1.IntPtr) 
fmt.Println(*t2.IntPtr) 

輸出

3 
3 

gob序列化反序列化

這是一種標準庫提供的編碼方法，類似于protobuf，Gob(即 Go binary 的縮寫)。類似于 Python 的pickle和 Java 的Serialization。

在發送端編碼，接收端解碼。

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 

基準測試(性能測試)

這三種方式我分別寫了基準測試的測試用例，go會自動反復調用，直到測算出一個合理的時間范圍。

基準測試代碼，這里僅寫一個，其他兩個函數的測試方式類似：

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環境下單核和多核并沒有明顯差異
• 運行速度快慢，手動拷貝方式 > json > gob
• 拷貝方式都相差了 2 個數量級

小結

如果是偶爾使用的程序可以使用json序列化反序列化的方式進行拷貝，但是除了慢以外還有一個缺陷，就是無法拷貝私有成員變量。

如果是頻繁拷貝的程序，建議使用手動拷貝方式進行拷貝，而且可以定制化拷貝的過程。甚至可以完成不同結構體之間，字段細微差異的定制化需求。

PS：內置copy和reflect.copy都只支持切片或數組的拷貝，內置copy速度是反射方式的兩倍以上。

拓展資料

• Go 語言使用 Gob 傳輸數據 http://c.biancheng.net/view/4597.html)
• 內建copy函數和reflect.Copy函數的區別 https://studygolang.com/topics/13523/comment/43357
• 基準測試 https://segmentfault.com/a/1190000016354758

 本文轉載自微信公眾號「機智的程序員小熊」，可以通過以下二維碼關注。轉載本文請聯系機智的程序員小熊公眾號。