Go語言常見的坑

這裡列舉的Go語言常見坑都是符合Go語言語法的，可以正常的編譯，但是可能是執行結果錯誤，或者是有資源洩漏的風險。

1. 可變引數是空介面型別

當引數的可變引數是空介面型別時，傳入空介面的切片時需要注意引數展開的問題。

package main

import "fmt"

func main() {

    var a = []interface{}{1, 2, 3}

    fmt.Println(a)

    fmt.Println(a...)

}

不管是否展開，編譯器都無法發現錯誤，但是輸出是不同的：

[1 2 3]

1 2 3

2. 陣列是值傳遞

在函式呼叫引數中，陣列是值傳遞，無法通過修改陣列型別的引數返回結果。

package main

import "fmt"

func main() {

	x := [3]int{1, 2, 3}

	// 匿名函式, 傳入陣列, 嘗試通過陣列索引修改陣列

	func(arr [3]int) {

		arr[0] = 7

		fmt.Println("arr:", arr)

	}(x)

	fmt.Println("x:", x)

}

輸出:

arr: [7 2 3]

x: [1 2 3]

必要時需要使用切片。

3.map遍歷是順序不固定

map是一種hash表實現，每次遍歷的順序都可能不一樣。

package main

import "fmt"

func main(){

    m := map[string]int{

        "1":1,

        "2":2,

        "3":3,

    }

    // 遍歷字典k,v

    for k, v := range m {

        fmt.Println(k, v)

    }

}

每次執行結果,輸出都不一樣

輸出:

3 3

1 1

2 2

4. 返回值被遮蔽

在區域性作用域中，命名的返回值內同名的區域性變數遮蔽：

package main

import "fmt"

func Bar() error {

	return fmt.Errorf("func err Bar()... ")

}

func Foo() (err error) {

	if err := Bar(); err != nil {

		return

	}

	return

}

func main() {

	err := Foo()

	fmt.Printf("err is %v", err)

}

重新定義返回的變數名,導致輸出錯誤, 輸出

D:\gopath\src\Go_base\lesson\someNots>go run demo.go

# command-line-arguments

.\demo.go:11:3: err is shadowed during return

5.recover必須在defer函式中執行

1. recover捕獲的是祖父級呼叫時的異常，直接呼叫時無效：

   package main
   
   func main() {
   
   	recover()
   
   	panic(1)
   
   }
   
   

   輸出:

   panic: 1
   
   goroutine 1 [running]:
   
   main.main()
   
           D:/gopath/src/Go_base/lesson/someNotes/recover1.go:5 +0x4e
   
   exit status 2
   
   

2. 直接defer呼叫也是無效：

   package main
   
   func main() {
   
   	defer recover()
   
   	panic(1)
   
   }
   
   

   會提示:

   defer should not call recover() directly
   
   

3. defer呼叫時多層巢狀依然無效：

   package main
   
   func main() {
   
   	// 第一層匿名函式
   
   	defer func() {
   
   		// 第二層
   
   		func() {
   
   			recover()
   
   		}()
   
   	}()
   
   	panic(1)
   
   }
   
   

正確方式:

必須在defer函式中直接呼叫才有效：

package main

import "fmt"

func main() {

	defer func() {

		err := recover()

		if err != nil {

			fmt.Printf("err:%v", err)

		}

	}()

	panic(1)

}

6. main函式提前退出

後臺Goroutine無法保證完成任務。

package main

func main() {

	go println("hello")

}

main函式相當於主執行緒, go啟用單獨的執行緒,無法滿足 一致性

7.通過Sleep來回避併發中的問題

休眠並不能保證輸出完整的字串：

package main

import "time"

func main() {

	go func() {

		time.Sleep(time.Microsecond)

		println("hello, this is a goroutine")

	}()

	time.Sleep(time.Microsecond)

}

因為主執行緒於協程之間並不能滿足一致性原則

8.獨佔CPU導致其它Goroutine餓死

Goroutine是協作式搶佔排程，Goroutine本身不會主動放棄CPU：

package main

import (

	"fmt"

	"runtime"

)

func main() {

	runtime.GOMAXPROCS(1)

	go func() {

		for i := 0; i < 10; i++ {

			fmt.Println(i)

		}

	}()

	for {

	} // 佔用CPU

}

結果會一直出於阻塞狀態

解決辦法

1. 解決的方法是在for迴圈加入runtime.Gosched()排程函式：

   package main
   
   import (
   
   	"fmt"
   
   	"runtime"
   
   )
   
   func main() {
   
   	runtime.GOMAXPROCS(1)
   
   	go func() {
   
   		for i := 0; i < 10; i++ {
   
   			fmt.Println(i)
   
   		}
   
   	}()
   
   	for {
   
   	    // 排程函式
   
   		runtime.Gosched()
   
   	}
   
   }
   
   

2. 通過阻塞的方式避免CPU佔用：

   package main
   
   import (
   
   	"fmt"
   
   	"os"
   
   	"runtime"
   
   )
   
   func main() {
   
   	runtime.GOMAXPROCS(1)
   
   	go func() {
   
   		for i := 0; i < 10; i++ {
   
   			fmt.Println(i)
   
   		}
   
   		os.Exit(0)
   
   	}()
   
   	select {}
   
   }
   
   

9. 不同Goroutine之間不滿足順序一致性記憶體模型

因為在不同的Goroutine，main函式中無法保證能打印出hello, world:

package main

var msg string

var done bool

func setup() {

	msg = "hello, world"

	done = true

}

func main() {

	go setup()

	println(done)

	for !done {

	}

	println(msg)

}

輸出:

false

hello, world

解決的辦法:是用顯式同步：

package main

import "fmt"

var msg string

var done = make(chan bool)

func setup() {

	msg = "hello, world"

	done <- true

}

func main() {

	go setup()

	// 無緩衝通道,寫入優先於讀取,所以當通道無資料時,會一直進行阻塞

	d := <-done

	fmt.Println(d)

	println(msg)

}

msg的寫入是在channel傳送之前，所以能保證列印hello, world

10. 閉包錯誤引用同一個變數

package main

func main() {

	for i := 0; i < 5; i++ {

	    // defer會壓棧,只會儲存最後一個變數值

		defer func() {

			println(i)

		}()

	}

}

輸出:

5

5

5

5

5

改進:

1. 在每輪迭代中生成一個區域性變數

   package main
   
   func main() {
   
   	for i := 0; i < 5; i++ {
   
   		i := i
   
   		// 輸出剛好相反, 壓棧先進後出
   
   		defer func() {
   
   			println(i)
   
   		}()
   
   	}
   
   }
   
   

2. 或者是通過函式引數傳入：

   package main
   
   func main() {
   
   	for i := 0; i < 5; i++ {
   
   		defer func(i int) {
   
   			println(i)
   
   		}(i)
   
   	}
   
   }
   
   

3. 輸出:

   4
   
   3
   
   2
   
   1
   
   0
   
   

11. 在迴圈內部執行defer語句

defer在*函式退出時才能執行**，所以直接在for迴圈內執行defer會導致資源延遲釋放：

package main

import (

	"log"

	"os"

)

func main() {

	for i := 0; i < 5; i++ {

		f, err := os.Open("/path/to/file")

		if err != nil {

			log.Fatal(err)

		}

		// 會導致同時開啟5個文件的操作控制代碼, 最後才會關閉

		defer f.Close()

	}

}

解決的方法:

在for中構造一個區域性函式，在區域性函式內部執行defer：

package main

import (

	"log"

	"os"

)

func main() {

	for i := 0; i < 5; i++ {

	    // 構建一個區域性函式

		func() {

			f, err := os.Open("/path/to/file")

			if err != nil {

				log.Fatal(err)

			}

			// 函式執行完畢後,就可以直接執行 close操作

			defer f.Close()

		}()

	}

}

12. 切片會導致整個底層陣列被鎖定

切片會導致整個底層陣列被鎖定，底層陣列無法釋放記憶體。如果底層陣列較大會對記憶體產生很大的壓力。

package main

import (

	"io/ioutil"

	"log"

)

func main() {

	headerMap := make(map[string][]byte)

	for i := 0; i < 5; i++ {

		name := "/path/to/file"

		// data是一個 byte陣列

		data, err := ioutil.ReadFile(name)

		if err != nil {

			log.Fatal(err)

		}

		// map賦值時,對陣列進行了切片

		headerMap[name] = data[:1]

	}

	// do some thing

}

解決的方法: 將結果克隆一份，這樣可以釋放底層的陣列：

package main

import (

	"io/ioutil"

	"log"

)

func main() {

	headerMap := make(map[string][]byte)

	for i := 0; i < 5; i++ {

		name := "/path/to/file"

		data, err := ioutil.ReadFile(name)

		if err != nil {

			log.Fatal(err)

		}

		// 將陣列data切片後直接克隆一份兒

		headerMap[name] = append([]byte{}, data[:1]...)

	}

	// do some thing

}

13. 空指標和空介面不等價

比如返回了一個錯誤指標，但是並不是空的error介面：

func returnsError() error {

    var p *MyError = nil

    if bad() {

        p = ErrBad

    }

    return p // Will always return a non-nil error.

}

14. 記憶體地址會變化

Go語言中物件的地址可能發生變化，因此指標不能從其它非指標型別的值生成：

package main

import (

	"runtime"

	"unsafe"

)

func main() {

	var x int = 42

	// p 為x的指標

	var p uintptr = uintptr(unsafe.Pointer(&x))

	runtime.GC()

	// 取地址

	var px *int = (*int)(unsafe.Pointer(p))

	println(*px)

}

當記憶體傳送變化的時候，相關的指標會同步更新，但是非指標型別的uintptr不會做同步更新。

同理CGO中也不能儲存Go物件地址。

15.Goroutine洩露

Go語言是帶記憶體自動回收的特性，因此記憶體一般不會洩漏。但是Goroutine確存在洩漏的情況，同時洩漏的Goroutine引用的記憶體同樣無法被回收。

package main

import "fmt"

func main() {

	// 定義一個匿名函式, 返回一個只讀int型別通

	ch := func() <-chan int {

		// 定義一個無緩衝讀寫通道

		ch := make(chan int)

		// 協程用於向通道寫入資料

		go func() {

			for i := 0; ; i++ {

				ch <- i

			}

		}()

		return ch

	}()

	// 遍歷結果

	for v := range ch {

		fmt.Println(v)

		if v == 5 {

			break

		}

	}

}

上面的程式中後臺Goroutine向管道輸入自然數序列，main函式中輸出序列。但是當break跳出for迴圈的時候，後臺Goroutine就處於無法被回收的狀態了。

解決方法: 可以通過context包來避免這個問題：

package main

import (

	"context"

	"fmt"

)

func main() {

	ctx, cancel := context.WithCancel(context.Background())

	ch := func(ctx context.Context) <-chan int {

		ch := make(chan int)

		go func() {

			for i := 0; ; i++ {

				select {

				case <-ctx.Done():

					return

				case ch <- i:

				}

			}

		}()

		return ch

	}(ctx)

	for v := range ch {

		fmt.Println(v)

		if v == 5 {

			cancel()

			break

		}

	}

}

當main函式在break跳出迴圈時，通過呼叫cancel()來通知後臺Goroutine退出，這樣就避免了Goroutine的洩漏

16. append錯誤使用導致無返回值

append的本質是向切片中追加資料，而隨著切片中元素逐漸增加，當切片底層的陣列將滿時，切片會發生擴容.

如下：

函式Validation()用於一些合法性檢查，每遇到一個錯誤，就生成一個新的error並追加到切片errs中，

最後返回包含所有錯誤資訊的切片。

為了簡單起見，假定函式發現了三個錯誤，如下所示：

func Validatior() []error {

    var errors []error

    append(errs, errors.New("error 1")

    append(errs, errors.New("error 2")

    append(errs, errors.New("error 3")

}

函式Validation()有什麼問題？

目前有很多的工具可以自動檢查出類似的問題，比如GolandIDE就會給出很明顯的提示。但是並不知道為何出錯。

append每個追加元素，都有可能觸發切片擴容，也即有可能返回一個新的切片，這也是append函式宣告中返回值為切片的原因。實際使用中應該總是接收該返回值。

上述題目一中，由於初始切片長度為0，所以實際上每次append都會產生一個新的切片並迅速拋棄（被gc回收）。

原始切片並沒有任何改變。需要特別說明的是，不管初始切片長度為多少，不接收append返回都是有極大風險的。

所以正確的方式如下：

func Validatior() []error {

    var errs []error

    errs=append(errs, errors.New("error 1")

    errr=append(errs, errors.New("error 2")

    errs=append(errs, errors.New("error 3")

}

17. append 可以追加nil值

函式ValidateName()用於檢查某個名字是否合法，如果不為空則認為合法，否則返回一個error。

類似的，還可以有很多檢查項，比如檢查性別、年齡等，我們統稱為子檢查項。

函式Validations()用於收集所有子檢查項的錯誤資訊，將錯誤資訊彙總到一個切片中返回。

請問函式Validations()有什麼問題？

func ValidateName(name string) error {

    if name != "" {

        return nil

    }

    return errors.New("empty name")

}

func Validations(name string) []error {

    var errs []error

    errs = append(errs, ValidateName(name))

    return errs

}

向切片中追加一個nil值是完全不會報錯的，如下程式碼所示：

slice := append(slice, nil)

經過追加後，slice的長度遞增1。

實際上nil是一個預定義的值，即空值，所以完全有理由向切片中追加。

單純從技術上講是沒有問題，但在使用場景中就有很大的問題。

比如你可能會根據切片的長度來判斷是否有錯誤發生，比如

func foo() {

    errs := Validations("")

    if len(errs) > 0 {

        println(errs)

        os.Exit(1)

    }

}

如果向切片中追加一個nil元素，那麼切片長度則不再為0，程式很可能因此而退出，更糟糕的是，這樣的切片是沒有內容會打印出來的，這無疑又增加了定位難度.

不定期更新

...