Go語言常見的坑
- 2021 年 8 月 4 日
- 筆記
- Golang基礎知識系列, Go常見的坑
- 1. 可變參數是空介面類型
- 2. 數組是值傳遞
- 3.map遍歷是順序不固定
- 4. 返回值被屏蔽
- 5.recover必須在defer函數中運行
- 6. main函數提前退出
- 7.通過Sleep來迴避並發中的問題
- 8.獨佔CPU導致其它Goroutine餓死
- 9. 不同Goroutine之間不滿足順序一致性記憶體模型
- 10. 閉包錯誤引用同一個變數
- 11. 在循環內部執行defer語句
- 12. 切片會導致整個底層數組被鎖定
- 13. 空指針和空介面不等價
- 14. 記憶體地址會變化
- 15.Goroutine泄露
- 16. append錯誤使用導致無返回值
- 17. append 可以追加nil值
- 不定期更新
這裡列舉的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函數中運行
- 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 - 直接defer調用也是無效：
package main func main() { defer recover() panic(1) }會提示:
defer should not call recover() directly - 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
}
結果會一直出於阻塞狀態
解決辦法
-
解決的方法是在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() } } -
通過阻塞的方式避免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
改進:
-
在每輪迭代中生成一個局部變數
package main func main() { for i := 0; i < 5; i++ { i := i // 輸出剛好相反, 壓棧先進後出 defer func() { println(i) }() } } -
或者是通過函數參數傳入：
package main func main() { for i := 0; i < 5; i++ { defer func(i int) { println(i) }(i) } } -
輸出:
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，程式很可能因此而退出，更糟糕的是，這樣的切片是沒有內容會列印出來的，這無疑又增加了定位難度.
不定期更新
…
