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函数中运行
- 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，程序很可能因此而退出，更糟糕的是，这样的切片是没有内容会打印出来的，这无疑又增加了定位难度.
不定期更新
...
Go语言常见的坑的更多相关文章
- Golang开发者常见的坑
Golang开发者常见的坑 目录 [−] 初级 开大括号不能放在单独的一行 未使用的变量 未使用的Imports 简式的变量声明仅可以在函数内部使用 使用简式声明重复声明变量 偶然的变量隐藏Accid ...
- 纯Socket(BIO)长链接编程的常见的坑和填坑套路
本文章纯属个人经验总结,伪代码也是写文章的时候顺便白板编码的,可能有逻辑问题,请帮忙指正,谢谢. Internet(全球互联网)是无数台机器基于TCP/IP协议族相互通信产生的.TCP/IP协议族分了 ...
- C语言常见命名规范
C语言常见命名规范 1 常见命名规则 比较著名的命名规则首推匈牙利命名法,这种命名方法是由Microsoft程序员查尔斯·西蒙尼(Charles Simonyi) 提出的.其主要思想是“在变量和函 ...
- C语言常见错误中英文对照表
C语言常见错误中英文对照表(网络搜索及经验积累不断更新中) 常见错误中英文对照表 fatal error C1003: error count exceeds number; stopping co ...
- 学习笔记之C/C++指针使用常见的坑
https://mp.weixin.qq.com/s/kEHQjmhNtSmV3MgHzw6YeQ 避免内存泄露 不再用到的内存没有释放,就叫做内存泄露 在C/C++中,通过动态内存分配函数(如mal ...
- 详讲H5、WebApp项目中常见的坑以及注意事项
首先我们中会有一些常用的meta标签,如下: <!--防止手机中网页放大和缩小--> <meta name="viewport" content="wi ...
- Android中常见的坑有哪些？
对于安卓开发入门级程序猿而言,由于不熟悉代码.工具等等,掉进一些坑中是难免的,今天小编在网上看到一位大神总结的Android开发中比较常见的坑及其原因和解决办法,赶脚还不错,分享出来,给大家提个醒. ...
- C语言常见的函数调用
C语言常见的函数调用 isatty,函数名,主要功能是检查设备类型,判断文件描述词是否为终端机. 函数名: isatty 用 法: int isatty(int desc); 返回值:如果参数desc ...
- Android使用WebView开发常见的坑
原文链接:http://mp.weixin.qq.com/s?__biz=MzAwODE1NTI2MQ==&tempkey=uP3a%2BOgIN7vPbLfJp3BTCl2KabYi1%2F ...
随机推荐
- 如何使用 jest 和 lint-staged 只检测发生改动的文件
我们现在在推进 EPC 的过程中,单元测试是必备的技能,在本地的 Git commit 之前进行单测非常有必要,总不能把所有的单测的压力都放在流水线上. 毕竟在流水线运行单测的成本还是挺高的,从 pu ...
- C#设计模式学习之装饰者模式
写这个随笔时,其实对该模式理解的并不是十分透彻.在此想到什么写什么,希望对自己对他人有所帮助. 装饰者模式主要是应用继承和组合的思想,极大的实现了程序的多态,使得的程序有了更高的扩展性. 第一个基础例 ...
- 测试MySQL锁的问题
测试MySQL锁的问题 目录 测试MySQL锁的问题 1 Record Lock 2 Next-Key Lock 2 死锁测试 InnoDB支持三种行锁: Record Lock:单个行记录上面的锁 ...
- 使用Spring Data JPA 访问 Mysql 数据库-配置项
jpa操作数据库 注意:数据库采用的是本机数据库,下面是建表语句及初始化数据: SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------- ...
- CosId 1.0.0 发布，通用、灵活、高性能的分布式 ID 生成器
CosId 通用.灵活.高性能的分布式 ID 生成器 介绍 CosId 旨在提供通用.灵活.高性能的分布式系统 ID 生成器. 目前提供了俩大类 ID 生成器:SnowflakeId (单机 TPS ...
- 15 自动发布Java项目（Tomcat）
#!/bin/bash export PAHT=/usr/local/maven/bin:/usr/local/jdk/bin:/usr/local/sbin:/usr/local/bin:/usr/ ...
- NoSql非关系型数据库之MongoDB应用(二)：安装MongoDB可视化工具
业精于勤,荒于嬉:行成于思,毁于随. 我们上次说到NoSql非关系型数据库之MongoDB应用(一):安装MongoDB服务 这次我们介绍安装 NoSQL Manager for MongoDB 可 ...
- Jenkins 进阶篇 - 权限配置
Jenkins的授权策略 Jenkins 默认的授权策略是[登录用户可以做任何事],也就是人人都是管理员,可以修改所有的设置以及构建所有的任务,不用做任何设置,有账号登录到 Jenkins 系统即可, ...
- Docker：虚拟机挂起后，再启动docker容器连接失败
问题描述 当我们使用VMware15 Pro 创建虚拟机并运行Linux搭建的Docker时,挂起虚拟机后再次运行发现访问Docker容器失败. 解决方式 我们正常的挂起其实是:挂起客户机,博主尝试 ...
- linux中如何添加用户并赋予root权限详解
#adduser username 修改 /etc/sudoers 文件,找到下面一行,在root下面添加一行,如下所示: ## Allow root to run any commands anyw ...