碼上快樂

相關內容    簡體    繁體

Go語言常見的坑

本文轉載自   查看原文   2021-08-04 07:35   401    Golang基礎知識系列/ 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，程序很可能因此而退出，更糟糕的是，這樣的切片是沒有內容會打印出來的，這無疑又增加了定位難度.

18. 循環變量綁定

首先看下如下幾種方式的代碼：

  1. 函數Process1()用於處理任務，每個任務均啟動一個協程進行處理。
func Process1(tasks []string) {
    for _, task := range tasks {
        // 啟動協程並發處理任務
        go func() {
            fmt.Printf("Worker start process task: %s\n", task)
        }()
    }
}

2.函數Process2()用於處理任務，每個任務均啟動一個協程進行處理。
協程匿名函數接收一個任務作為參數，並進行處理。

func Process2(tasks []string) {
    for _, task := range tasks {
        // 啟動協程並發處理任務
        go func(t string) {
            fmt.Printf("Worker start process task: %s\n", t)
        }(task)
    }
}

3.項目中經常需要編寫單元測試，而單元測試最常見的是table-driven風格的測試，如下所示：
待測函數很簡單，只是計算輸入數值的2倍值。

func Double(a int) int {
    return a * 2
}

測試函數如下：

func TestDouble(t *testing.T) {
    var tests = []struct {
        name         string
        input        int
        expectOutput int
    }{
        {
            name:         "double 1 should got 2",
            input:        1,
            expectOutput: 2,
        },
        {
            name:         "double 2 should got 4",
            input:        2,
            expectOutput: 4,
        },
    }

    for _, test := range tests {
        t.Run(test.name, func(t *testing.T) {
            if test.expectOutput != Double(test.input) {
                t.Fatalf("expect: %d, but got: %d", test.input, test.expectOutput)
            }
        })
    }
}

上述測試函數也很簡單，通過設計多個測試用例，標記輸入輸出，使用子測試進行驗證。

上述三個函數是否有問題？

原理剖析

有個共同點就是都引用了循環變量。即在for index, value := range xxx語句中，
index和value便是循環變量。不同點是循環變量的使用方式，有的是直接在協程中引用（1），有的作為參數傳遞（2），而3則是兼而有之。

回答以上問題，記住以下兩點即可。

1.循環變量是易變的

首先，循環變量實際上只是一個普通的變量。

語句for index, value := range xxx中，每次循環index和value都會被重新賦值（並非生成新的變量）。

如果循環體中會啟動協程（並且協程會使用循環變量），就需要格外注意了，因為很可能循環結束后協程才開始執行 ,
此時，所有協程使用的循環變量有可能已被改寫。（是否會改寫取決於引用循環變量的方式）

2. 虛幻變量需要綁定

1.（1）中，協程函數體中引用了循環變task，協程從被創建到被調度執行期間循環變量極有可能被改寫，這種情況下，我們稱之為變量沒有綁定。函數1 打印結果是混亂的。很有可能（隨機）所有協程執行的task都是列表中的最后一個task。

  1. 函數2中，協程函數體中並沒有直接引用循環變量task，而是使用的參數。而在創建協程時，循環變量task
    作為函數參數傳遞給了協程。參數傳遞的過程實際上也生成了新的變量，也即間接完成了綁定。所以，題目二實際上是沒有問題的。

  2. 測試函數3 ，測試用例名字test.name通過函數參數完成了綁定，而test.input 和 test.expectOutput則沒有綁定。然而題目三實際執行卻不會有問題，因為t.Run(...)並不會啟動新的協程，也就是循環體並沒有並發。此時，即便循環變量沒有綁定也沒有問題。

    但是風險在於，如果t.Run(...)執行的測試體有可能並發（比如通過t.Parallel()），此時就極有可能引入問題。

對於3中的測試用例，建議顯式地綁定，例如：

    for _, test := range tests {
        tc := test // 顯式綁定，每次循環都會生成一個新的tc變量
        t.Run(tc.name, func(t *testing.T) {
            if tc.expectOutput != Double(tc.input) {
                t.Fatalf("expect: %d, but got: %d", tc.input, tc.expectOutput)
            }
        })
    }

通過tc := test顯式地綁定，每次循環會生成一個新的變量。

3.總結

簡單點來說

  • 如果循環體沒有並發出現，則引用循環變量一般不會出現問題；
  • 如果循環體有並發，則根據引用循環變量的位置不同而有所區別
    • 通過參數完成綁定，則一般沒有問題；
    • 函數體中引用，則需要顯式地綁定

不定期更新

...


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Go語言常見坑 學習-go語言坑之for range go語言的坑:切片的拷貝問題 Go語言結構體轉json的坑 網絡相關和Go語言踩坑 Go語言file-rotatelogs的小坑 Go語言http包Form解析之坑 go語言gorm踩坑筆記 Go語言踩過的坑---記錄GOPATH在GOLAND中的坑 Go語言 踩坑錄（報錯錦集）
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM