数组是值传递 在函数调用参数中, 数组是值传递, 无法通过修改数组类型的参数返回结果.
func main() {
x := [3]int{1, 2, 3}
func(arr [3]int) {
arr[0] = 7
fmt.Println(arr)
}(x)
fmt.Println(x)
复制代码} 必要时需要使用切片.
map遍历是顺序不固定 map是一种hash表实现, 每次遍历的顺序都可能不一样.
func main() { m := map[string]string{ "1": "1", "2": "2", "3": "3", }
for k, v := range m {
println(k, v)
}
复制代码} 返回值被屏蔽 在局部作用域中, 命名的返回值内同名的局部变量屏蔽:
func Foo() (err error) { if err := Bar(); err != nil { return } return } recover必须在defer函数中运行 recover捕获的是祖父级调用时的异常, 直接调用时无效:
func main() {
recover()
panic(1)
}
直接defer调用也是无效:
func main() {
defer recover()
panic(1)
}
defer调用时多层嵌套依然无效:
func main() {
defer func() {
func() { recover() }()
}()
panic(1)
}
必须在defer函数中直接调用才有效:
func main() {
defer func() {
recover()
}()
panic(1)
}
main函数提前退出
后台Goroutine无法保证完成任务.
func main() { go println("hello") } 通过Sleep来回避并发中的问题 休眠并不能保证输出完整的字符串:
func main() { go println("hello") time.Sleep(time.Second) } 类似的还有通过插入调度语句:
func main() { go println("hello") runtime.Gosched() } 独占CPU导致其它Goroutine饿死 Goroutine是协作式调度, Goroutine本身不会主动放弃CPU:
func main() { runtime.GOMAXPROCS(1)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}()
for {} // 占用CPU
复制代码} 解决的方法是在for循环加入runtime.Gosched()调度函数:
func main() { runtime.GOMAXPROCS(1)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}()
for {
runtime.Gosched()
}
复制代码} 或者是通过阻塞的方式避免CPU占用:
func main() { runtime.GOMAXPROCS(1)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(i)
}
}()
select{}
复制代码} 不同Goroutine之间不满足顺序一致性内存模型 因为在不同的Goroutine, main函数可能无法观测到done的状态变化, 那么for循环会陷入死循环:
var msg string var done bool = false
func main() { runtime.GOMAXPROCS(1)
go func() {
msg = "hello, world"
done = true
}()
for {
if done {
println(msg)
break
}
}
复制代码} 解决的办法是用显示同步:
var msg string var done = make(chan bool)
func main() { runtime.GOMAXPROCS(1)
go func() {
msg = "hello, world"
done <- true
}()
<-done
println(msg)
复制代码} 闭包错误引用同一个变量 func main() { for i := 0; i < 5; i++ { defer func() { println(i) }() } } 改进的方法是在每轮迭代中生成一个局部变量
func main() { for i := 0; i < 5; i++ { i := i defer func() { println(i) }() } } 或者是通过函数参数传入
func main() { for i := 0; i < 5; i++ { defer func(i int) { println(i) }(i) } } 在循环内部执行defer语句 defer在函数退出时才能执行, 在for执行defer会导致资源延迟释放:
func main() { for i := 0; i < 5; i++ { f, err := os.Open("/path/to/file") if err != nil { log.Fatal(err) } defer f.Close() } } 解决的方法可以在for中构造一个局部函数, 在局部函数内部执行defer:
func main() { for i := 0; i < 5; i++ { func() { f, err := os.Open("/path/to/file") if err != nil { log.Fatal(err) } defer f.Close() }() } } 切片会导致整个底层数组被锁定 切片会导致整个底层数组被锁定, 底层数组无法释放内存. 如果底层数组较大会对内存产生很大的压力.
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)
}
headerMap[name] = data[:1]
}
// do some thing
复制代码} 解决的方法是将结果克隆一份, 这样可以释放底层的数组:
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)
}
headerMap[name] = append([]byte{}, data[:1]...)
}
// do some thing
复制代码} 空指针和空接口不等价 比如返回了一个错误指针, 但是并不是空的error接口:
func returnsError() error { var p *MyError = nil if bad() { p = ErrBad } return p // Will always return a non-nil error. } 内存地址会变化 Go语言中对象的地址可能发生变化, 因此指针不能从其它非指针类型的值生成:
func main() { var x int = 42 var p uintptr = uintptr(unsafe.Poiner(&x))
runtime.GC()
var px *int = (*int)(unsafe.Poiner(p))
println(*px)
复制代码} 当内存发送变化的时候, 相关的指针会同步更新, 但是非指针类型的uintptr不会做同步更新.
同理, cgo中也不能保存Go对象地址.
Goroutine泄露 Go语言是带内存自动回收的特性，因此内存一般不会泄漏。但是Goroutine确存在泄漏的情况，同时泄漏的Goroutine引用的内存同样无法被回收。
func main() { 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就处于无法被回收的状态了。
我们可以通过contxt包来避免做个问题：
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
}
}
复制代码}