Go是一门简单有趣的语言，但与其他语言类似，它会有一些技巧。。。这些技巧的绝大部分并不是Go的缺陷造成的。如果你以前使用的是其他语言，那么这其中的有些错误就是很自然的陷阱。其它的是由错误的假设和缺少细节造成的。
如果你花时间学习这门语言，阅读官方说明、wiki、邮件列表讨论、大量的优秀博文和Rob Pike的展示，以及源代码，这些技巧中的绝大多数都是显而易见的。尽管不是每个人都是以这种方式开始学习的，但也没关系。如果你是Go语言新人，那么这里的信息将会节约你大量的调试代码的时间。
目录
初级篇
开大括号不能放在单独的一行
未使用的变量
未使用的Imports
简式的变量声明仅可以在函数内部使用
使用简式声明重复声明变量
偶然的变量隐藏Accidental Variable Shadowing
不使用显式类型，无法使用“nil”来初始化变量
使用“nil” Slices and Maps
Map的容量
字符串不会为“nil”
Array函数的参数
在Slice和Array使用“range”语句时的出现的不希望得到的值
Slices和Arrays是一维的
访问不存在的Map Keys
Strings无法修改
String和Byte Slice之间的转换
String和索引操作
字符串不总是UTF8文本
字符串的长度
在多行的Slice、Array和Map语句中遗漏逗号
log.Fatal和log.Panic不仅仅是Log
内建的数据结构操作不是同步的
String在“range”语句中的迭代值
对Map使用“for range”语句迭代
"switch"声明中的失效行为
自增和自减
按位NOT操作
操作优先级的差异
未导出的结构体不会被编码
有活动的Goroutines下的应用退出
向无缓存的Channel发送消息，只要目标接收者准备好就会立即返回
向已关闭的Channel发送会引起Panic
使用"nil" Channels
传值方法的接收者无法修改原有的值
进阶篇
关闭HTTP的响应
关闭HTTP的连接
比较Structs, Arrays, Slices, and Maps
从Panic中恢复
在Slice, Array, and Map "range"语句中更新引用元素的值
在Slice中"隐藏"数据
Slice的数据“毁坏”
"走味的"Slices
类型声明和方法
从"for switch"和"for select"代码块中跳出
"for"声明中的迭代变量和闭包
Defer函数调用参数的求值
被Defer的函数调用执行
失败的类型断言
阻塞的Goroutine和资源泄露
高级篇
使用指针接收方法的值的实例
更新Map的值
"nil" Interfaces和"nil" Interfaces的值
栈和堆变量
GOMAXPROCS, 并发, 和并行
读写操作的重排顺序
优先调度
初级篇
开大括号不能放在单独的一行
- level: beginner
在大多数其他使用大括号的语言中，你需要选择放置它们的位置。Go的方式不同。你可以为此感谢下自动分号的注入（没有预读）。是的，Go中也是有分号的：-）
失败的例子：
package mainimport"fmt"func main(){//error, can't have the opening brace on a separate line fmt.Println("hello there!")}复制代码编译错误：
/tmp/sandbox826898458/main.go:6: syntax error: unexpected semicolon or newline before {复制代码有效的例子：
package mainimport"fmt"func main(){ fmt.Println("works!")}复制代码未使用的变量
- level: beginner
如果你有未使用的变量，代码将编译失败。当然也有例外。在函数内一定要使用声明的变量，但未使用的全局变量是没问题的。
如果你给未使用的变量分配了一个新的值，代码还是会编译失败。你需要在某个地方使用这个变量，才能让编译器愉快的编译。
Fails:
package mainvar gvar int//not an errorfunc main(){var one int//error, unused variable two :=2//error, unused variablevar three int//error, even though it's assigned 3 on the next line three =3}复制代码Compile Errors:
/tmp/sandbox473116179/main.go:6: one declared andnot used /tmp/sandbox473116179/main.go:7: two declared andnot used /tmp/sandbox473116179/main.go:8: three declared andnot used复制代码Works:
package mainimport"fmt"func main(){var one int _ = one two :=2 fmt.Println(two)var three int three =3 one = three var four int four = four}复制代码另一个选择是注释掉或者移除未使用的变量 ：-）
未使用的Imports
- level: beginner
如果你引入一个包，而没有使用其中的任何函数、接口、结构体或者变量的话，代码将会编译失败。
如果你真的需要引入的包，你可以添加一个下划线标记符， _，来作为这个包的名字，从而避免编译失败。下滑线标记符用于引入，但不使用。
Fails:
package mainimport("fmt""log""time")func main(){}复制代码Compile Errors:
/tmp/sandbox627475386/main.go:4: imported andnot used:"fmt"/tmp/sandbox627475386/main.go:5: imported andnot used:"log"/tmp/sandbox627475386/main.go:6: imported andnot used:"time"复制代码Works:
package mainimport( _ "fmt""log""time")var _ = log.Printlnfunc main(){ _ = time.Now}复制代码另一个选择是移除或者注释掉未使用的imports ：-）
简式的变量声明仅可以在函数内部使用
- level: beginner
Fails:
package mainmyvar :=1//errorfunc main(){}复制代码Compile Error:
/tmp/sandbox265716165/main.go:3: non-declaration statement outside function body复制代码Works:
package mainvar myvar =1func main(){}复制代码使用简式声明重复声明变量
- level: beginner
你不能在一个单独的声明中重复声明一个变量，但在多变量声明中这是允许的，其中至少要有一个新的声明变量。
重复变量需要在相同的代码块内，否则你将得到一个隐藏变量。
Fails:
package mainfunc main(){ one :=0 one :=1//error}复制代码Compile Error:
/tmp/sandbox706333626/main.go:5:nonew variables on left side of :=复制代码Works:
package mainfunc main(){ one :=0 one, two :=1,2 one,two = two,one}复制代码偶然的变量隐藏Accidental Variable Shadowing
- level: beginner
短式变量声明的语法如此的方便（尤其对于那些使用过动态语言的开发者而言），很容易让人把它当成一个正常的分配操作。如果你在一个新的代码块中犯了这个错误，将不会出现编译错误，但你的应用将不会做你所期望的事情。
package mainimport"fmt"func main(){ x :=1 fmt.Println(x)//prints 1{ fmt.Println(x)//prints 1 x :=2 fmt.Println(x)//prints 2} fmt.Println(x)//prints 1 (bad if you need 2)}复制代码即使对于经验丰富的Go开发者而言，这也是一个非常常见的陷阱。这个坑很容易挖，但又很难发现。
不使用显式类型，无法使用“nil”来初始化变量
- level: beginner
“nil”标志符用于表示interface、函数、maps、slices和channels的“零值”。如果你不指定变量的类型，编译器将无法编译你的代码，因为它猜不出具体的类型。
Fails:
package mainfunc main(){var x =nil//error _ = x}复制代码Compile Error:
/tmp/sandbox188239583/main.go:4:use of untyped nil复制代码Works:
package mainfunc main(){var x interface{}=nil _ = x}复制代码使用“nil” Slices and Maps
- level: beginner
在一个“nil”的slice中添加元素是没问题的，但对一个map做同样的事将会生成一个运行时的panic。
Works:
package mainfunc main(){var s []int s = append(s,1)}复制代码Fails:
package mainfunc main(){var m map[string]int m["one"]=1//error}复制代码Map的容量
- level: beginner
你可以在map创建时指定它的容量，但你无法在map上使用cap()函数。
Fails:
package mainfunc main(){ m := make(map[string]int,99) cap(m)//error}复制代码Compile Error:
/tmp/sandbox326543983/main.go:5: invalid argument m (type map[string]int)for cap复制代码字符串不会为“nil”
- level: beginner
这对于经常使用“nil”分配字符串变量的开发者而言是个需要注意的地方。
Fails:
package mainfunc main(){var x string=nil//errorif x ==nil{//error x ="default"}}复制代码Compile Errors:
/tmp/sandbox630560459/main.go:4: cannot usenilas type stringin assignment /tmp/sandbox630560459/main.go:6: invalid operation: x ==nil(mismatched types stringandnil)复制代码Works:
package mainfunc main(){var x string//defaults to "" (zero value)if x ==""{ x ="default"}}复制代码Array函数的参数
-level: beginner
如果你是一个C或则C++开发者，那么数组对你而言就是指针。当你向函数中传递数组时，函数会参照相同的内存区域，这样它们就可以修改原始的数据。Go中的数组是数值，因此当你向函数中传递数组时，函数会得到原始数组数据的一份复制。如果你打算更新数组的数据，这将会是个问题。
package mainimport"fmt"func main(){ x :=[3]int{1,2,3} func(arr [3]int){ arr[0]=7 fmt.Println(arr)//prints [7 2 3]}(x) fmt.Println(x)//prints [1 2 3] (not ok if you need [7 2 3])}复制代码如果你需要更新原始数组的数据，你可以使用数组指针类型。
package mainimport"fmt"func main(){ x :=[3]int{1,2,3} func(arr *[3]int){(*arr)[0]=7 fmt.Println(arr)//prints &[7 2 3]}(&x) fmt.Println(x)//prints [7 2 3]}复制代码另一个选择是使用slice。即使你的函数得到了slice变量的一份拷贝，它依旧会参照原始的数据。
package mainimport"fmt"func main(){ x :=[]int{1,2,3} func(arr []int){ arr[0]=7 fmt.Println(arr)//prints [7 2 3]}(x) fmt.Println(x)//prints [7 2 3]}复制代码在Slice和Array使用“range”语句时的出现的不希望得到的值
- level: beginner
如果你在其他的语言中使用“for-in”或者“foreach”语句时会发生这种情况。Go中的“range”语法不太一样。它会得到两个值：第一个值是元素的索引，而另一个值是元素的数据。
Bad:
package mainimport"fmt"func main(){ x :=[]string{"a","b","c"}for v := range x { fmt.Println(v)//prints 0, 1, 2}}复制代码Good:
package mainimport"fmt"func main(){ x :=[]string{"a","b","c"}for _, v := range x { fmt.Println(v)//prints a, b, c}}复制代码Slices和Arrays是一维的
- level: beginner
看起来Go好像支持多维的Array和Slice，但不是这样的。尽管可以创建数组的数组或者切片的切片。对于依赖于动态多维数组的数值计算应用而言，Go在性能和复杂度上还相距甚远。
你可以使用纯一维数组、“独立”切片的切片，“共享数据”切片的切片来构建动态的多维数组。
如果你使用纯一维的数组，你需要处理索引、边界检查、当数组需要变大时的内存重新分配。
使用“独立”slice来创建一个动态的多维数组需要两步。首先，你需要创建一个外部的slice。然后，你需要分配每个内部的slice。内部的slice相互之间独立。你可以增加减少它们，而不会影响其他内部的slice。
package mainfunc main(){ x :=2 y :=4 table := make([][]int,x)for i:= range table { table[i]= make([]int,y)}}复制代码使用“共享数据”slice的slice来创建一个动态的多维数组需要三步。首先，你需要创建一个用于存放原始数据的数据“容器”。然后，你再创建外部的slice。最后，通过重新切片原始数据slice来初始化各个内部的slice。
package mainimport"fmt"func main(){ h, w :=2,4 raw := make([]int,h*w)for i := range raw { raw[i]= i } fmt.Println(raw,&raw[4])//prints: [0 1 2 3 4 5 6 7] <ptr_addr_x> table := make([][]int,h)for i:= range table { table[i]= raw[i*w:i*w + w]} fmt.Println(table,&table[1][0])//prints: [[0 1 2 3] [4 5 6 7]] <ptr_addr_x>}复制代码关于多维array和slice已经有了专门申请，但现在看起来这是个低优先级的特性。
访问不存在的Map Keys
-level: beginner
这对于那些希望得到“nil”标示符的开发者而言是个技巧（和其他语言中做的一样）。如果对应的数据类型的“零值”是“nil”，那返回的值将会是“nil”，但对于其他的数据类型是不一样的。检测对应的“零值”可以用于确定map中的记录是否存在，但这并不总是可信（比如，如果在二值的map中“零值”是false，这时你要怎么做）。检测给定map中的记录是否存在的最可信的方法是，通过map的访问操作，检查第二个返回的值。
Bad:
package mainimport"fmt"func main(){ x := map[string]string{"one":"a","two":"","three":"c"}if v := x["two"]; v ==""{//incorrect fmt.Println("no entry")}}复制代码Good:
package mainimport"fmt"func main(){ x := map[string]string{"one":"a","two":"","three":"c"}if _,ok := x["two"];!ok { fmt.Println("no entry")}}复制代码Strings无法修改
- level: beginner
尝试使用索引操作来更新字符串变量中的单个字符将会失败。string是只读的byte slice（和一些额外的属性）。如果你确实需要更新一个字符串，那么使用byte slice，并在需要时把它转换为string类型。
Fails:
package mainimport"fmt"func main(){ x :="text" x[0]='T' fmt.Println(x)}复制代码Compile Error:
/tmp/sandbox305565531/main.go:7: cannot assign to x[0]复制代码Works:
package mainimport"fmt"func main(){ x :="text" xbytes :=[]byte(x) xbytes[0]='T' fmt.Println(string(xbytes))//prints Text}复制代码需要注意的是：这并不是在文字string中更新字符的正确方式，因为给定的字符可能会存储在多个byte中。如果你确实需要更新一个文字string，先把它转换为一个rune slice。即使使用rune slice，单个字符也可能会占据多个rune，比如当你的字符有特定的重音符号时就是这种情况。这种复杂又模糊的“字符”本质是Go字符串使用byte序列表示的原因。
String和Byte Slice之间的转换
- level: beginner
当你把一个字符串转换为一个byte slice（或者反之）时，你就得到了一个原始数据的完整拷贝。这和其他语言中cast操作不同，也和新的slice变量指向原始byte slice使用的相同数组时的重新slice操作不同。
Go在 []byte到 string和 string到 []byte的转换中确实使用了一些优化来避免额外的分配（在todo列表中有更多的优化）。
第一个优化避免了当 []bytekey用于在 map[string]集合中查询时的额外分配: m[string(key)]。
第二个优化避免了字符串转换为 []byte后在 for range语句中的额外分配： for i,v := range []byte(str){...}。
String和索引操作
- level: beginner
字符串上的索引操作返回一个byte值，而不是一个字符（和其他语言中的做法一样）。
package mainimport"fmt"func main(){ x :="text" fmt.Println(x[0])//print 116 fmt.Printf("%T",x[0])//prints uint8}复制代码如果你需要访问特定的字符串“字符”（unicode编码的points/runes），使用 for range。官方的“unicode/utf8”包和实验中的utf8string包（golang.org/x/exp/utf8string）也可以用。utf8string包中包含了一个很方便的 At()方法。把字符串转换为rune的切片也是一个选项。
字符串不总是UTF8文本
- level: beginner
字符串的值不需要是UTF8的文本。它们可以包含任意的字节。只有在string literal使用时，字符串才会是UTF8。即使之后它们可以使用转义序列来包含其他的数据。
为了知道字符串是否是UTF8，你可以使用“unicode/utf8”包中的 ValidString()函数。
package mainimport("fmt""unicode/utf8")func main(){ data1 :="ABC" fmt.Println(utf8.ValidString(data1))//prints: true data2 :="A\xfeC" fmt.Println(utf8.ValidString(data2))//prints: false}复制代码字符串的长度
- level: beginner
让我们假设你是Python开发者，你有下面这段代码：
data = u'♥'print(len(data))#prints: 1 复制代码当把它转换为Go代码时，你可能会大吃一惊。
package mainimport"fmt"func main(){ data :="♥" fmt.Println(len(data))//prints: 3}复制代码内建的 len()函数返回byte的数量，而不是像Python中计算好的unicode字符串中字符的数量。
要在Go中得到相同的结果，可以使用“unicode/utf8”包中的 RuneCountInString()函数。
package mainimport("fmt""unicode/utf8")func main(){ data :="♥" fmt.Println(utf8.RuneCountInString(data))//prints: 1}复制代码理论上说 RuneCountInString()函数并不返回字符的数量，因为单个字符可能占用多个rune。
package mainimport("fmt""unicode/utf8")func main(){ data :="é" fmt.Println(len(data))//prints: 3 fmt.Println(utf8.RuneCountInString(data))//prints: 2}复制代码在多行的Slice、Array和Map语句中遗漏逗号
- level: beginner
Fails:
package mainfunc main(){ x :=[]int{1,2//error} _ = x}复制代码Compile Errors:
/tmp/sandbox367520156/main.go:6: syntax error: need trailing comma before newline in composite literal /tmp/sandbox367520156/main.go:8: non-declaration statement outside function body /tmp/sandbox367520156/main.go:9: syntax error: unexpected }复制代码Works:
package mainfunc main(){ x :=[]int{1,2,} x = x y :=[]int{3,4,}//no error y = y}复制代码当你把声明折叠到单行时，如果你没加末尾的逗号，你将不会得到编译错误。
log.Fatal和log.Panic不仅仅是Log
- level: beginner
Logging库一般提供不同的log等级。与这些logging库不同，Go中log包在你调用它的 Fatal*()和 Panic*()函数时，可以做的不仅仅是log。当你的应用调用这些函数时，Go也将会终止应用 🙂
package mainimport"log"func main(){ log.Fatalln("Fatal Level: log entry")//app exits here log.Println("Normal Level: log entry")}复制代码内建的数据结构操作不是同步的
- level: beginner
即使Go本身有很多特性来支持并发，并发安全的数据集合并不是其中之一 :-)确保数据集合以原子的方式更新是你的职责。Goroutines和channels是实现这些原子操作的推荐方式，但你也可以使用“sync”包，如果它对你的应用有意义的话。
String在“range”语句中的迭代值
- level: beginner
索引值（“range”操作返回的第一个值）是返回的第二个值的当前“字符”（unicode编码的point/rune）的第一个byte的索引。它不是当前“字符”的索引，这与其他语言不同。注意真实的字符可能会由多个rune表示。如果你需要处理字符，确保你使用了“norm”包（golang.org/x/text/unicode/norm）。
string变量的 for range语句将会尝试把数据翻译为UTF8文本。对于它无法理解的任何byte序列，它将返回0xfffd runes（即unicode替换字符），而不是真实的数据。如果你任意（非UTF8文本）的数据保存在string变量中，确保把它们转换为byte slice，以得到所有保存的数据。
package mainimport"fmt"func main(){ data :="A\xfe\x02\xff\x04"for _,v := range data { fmt.Printf("%#x ",v)}//prints: 0x41 0xfffd 0x2 0xfffd 0x4 (not ok) fmt.Println()for _,v := range []byte(data){ fmt.Printf("%#x ",v)}//prints: 0x41 0xfe 0x2 0xff 0x4 (good)}复制代码对Map使用“for range”语句迭代
- level: beginner
如果你希望以某个顺序（比如，按key值排序）的方式得到元素，就需要这个技巧。每次的map迭代将会生成不同的结果。Go的runtime有心尝试随机化迭代顺序，但并不总会成功，这样你可能得到一些相同的map迭代结果。所以如果连续看到5个相同的迭代结果，不要惊讶。
package mainimport"fmt"func main(){ m := map[string]int{"one":1,"two":2,"three":3,"four":4}for k,v := range m { fmt.Println(k,v)}}复制代码而且如果你使用Go的游乐场（play.golang.org/)，你将总会得到同样的结果，因为除非你修改代码，否则它不会重新编译代码。
"switch"声明中的失效行为
- level: beginner
在“switch”声明语句中的“case”语句块在默认情况下会break。这和其他语言中的进入下一个“next”代码块的默认行为不同。
package mainimport"fmt"func main(){ isSpace := func(ch byte)bool{switch(ch){case' '://errorcase'\t':returntrue}returnfalse} fmt.Println(isSpace('\t'))//prints true (ok) fmt.Println(isSpace(' '))//prints false (not ok)}复制代码你可以通过在每个“case”块的结尾使用“fallthrough”，来强制“case”代码块进入。你也可以重写switch语句，来使用“case”块中的表达式列表。
package mainimport"fmt"func main(){ isSpace := func(ch byte)bool{switch(ch){case' ','\t':returntrue}returnfalse} fmt.Println(isSpace('\t'))//prints true (ok) fmt.Println(isSpace(' '))//prints true (ok)}复制代码自增和自减
- level: beginner
许多语言都有自增和自减操作。不像其他语言，Go不支持前置版本的操作。你也无法在表达式中使用这两个操作符。
Fails:
package mainimport"fmt"func main(){ data :=[]int{1,2,3} i :=0++i //error fmt.Println(data[i++])//error}复制代码Compile Errors:
/tmp/sandbox101231828/main.go:8: syntax error: unexpected ++/tmp/sandbox101231828/main.go:9: syntax error: unexpected ++, expecting :复制代码Works:
package mainimport"fmt"func main(){ data :=[]int{1,2,3} i :=0 i++ fmt.Println(data[i])}复制代码按位NOT操作
- level: beginner
许多语言使用 ~ 作为一元的NOT操作符（即按位补足），但Go为了这个重用了XOR操作符（ ^）。
Fails:
package mainimport"fmt"func main(){ fmt.Println(~2)//error}复制代码Compile Error:
/tmp/sandbox965529189/main.go:6: the bitwise complement operatoris^复制代码Works:
package mainimport"fmt"func main(){var d uint8 =2 fmt.Printf("%08b\n",^d)}复制代码Go依旧使用 ^作为XOR的操作符，这可能会让一些人迷惑。
如果你愿意，你可以使用一个二元的XOR操作（如， 0x02 XOR 0xff）来表示一个一元的NOT操作（如，NOT 0x02）。这可以解释为什么 ^被重用来表示一元的NOT操作。
Go也有特殊的‘AND NOT’按位操作（ &^），这也让NOT操作更加的让人迷惑。这看起来需要特殊的特性/hack来支持 A AND (NOT B)，而无需括号。
package mainimport"fmt"func main(){var a uint8 =0x82var b uint8 =0x02 fmt.Printf("%08b [A]\n",a) fmt.Printf("%08b [B]\n",b) fmt.Printf("%08b (NOT B)\n",^b) fmt.Printf("%08b ^ %08b = %08b [B XOR 0xff]\n",b,0xff,b ^0xff) fmt.Printf("%08b ^ %08b = %08b [A XOR B]\n",a,b,a ^ b) fmt.Printf("%08b & %08b = %08b [A AND B]\n",a,b,a & b) fmt.Printf("%08b &^%08b = %08b [A 'AND NOT' B]\n",a,b,a &^ b) fmt.Printf("%08b&(^%08b)= %08b [A AND (NOT B)]\n",a,b,a &(^b))}复制代码操作优先级的差异
- level: beginner
除了”bit clear“操作（ &^），Go也一个与许多其他语言共享的标准操作符的集合。尽管操作优先级并不总是一样。
package mainimport"fmt"func main(){ fmt.Printf("0x2 & 0x2 + 0x4 -> %#x\n",0x2&0x2+0x4)//prints: 0x2 & 0x2 + 0x4 -> 0x6//Go: (0x2 & 0x2) + 0x4//C++: 0x2 & (0x2 + 0x4) -> 0x2 fmt.Printf("0x2 + 0x2 << 0x1 -> %#x\n",0x2+0x2<<0x1)//prints: 0x2 + 0x2 << 0x1 -> 0x6//Go: 0x2 + (0x2 << 0x1)//C++: (0x2 + 0x2) << 0x1 -> 0x8 fmt.Printf("0xf | 0x2 ^ 0x2 -> %#x\n",0xf|0x2^0x2)//prints: 0xf | 0x2 ^ 0x2 -> 0xd//Go: (0xf | 0x2) ^ 0x2//C++: 0xf | (0x2 ^ 0x2) -> 0xf}复制代码未导出的结构体不会被编码
- level: beginner
以小写字母开头的结构体将不会被（json、xml、gob等）编码，因此当你编码这些未导出的结构体时，你将会得到零值。
Fails:
package mainimport("fmt""encoding/json")type MyDatastruct{Oneint two string}func main(){in:=MyData{1,"two"} fmt.Printf("%#v\n",in)//prints main.MyData{One:1, two:"two"} encoded,_ := json.Marshal(in) fmt.Println(string(encoded))//prints {"One":1}varoutMyData json.Unmarshal(encoded,&out) fmt.Printf("%#v\n",out)//prints main.MyData{One:1, two:""}}复制代码有活动的Goroutines下的应用退出
- level: beginner
应用将不会得带所有的goroutines完成。这对于初学者而言是个很常见的错误。每个人都是以某个程度开始，因此如果犯了初学者的错误也没神马好丢脸的 🙂
package mainimport("fmt""time")func main(){ workerCount :=2for i :=0; i < workerCount; i++{ go doit(i)} time.Sleep(1* time.Second) fmt.Println("all done!")}func doit(workerId int){ fmt.Printf("[%v] is running\n",workerId) time.Sleep(3* time.Second) fmt.Printf("[%v] is done\n",workerId)}复制代码你将会看到：
[0]is running[1]is runningall done!复制代码一个最常见的解决方法是使用“WaitGroup”变量。它将会让主goroutine等待所有的worker goroutine完成。如果你的应用有长时运行的消息处理循环的worker，你也将需要一个方法向这些goroutine发送信号，让它们退出。你可以给各个worker发送一个“kill”消息。另一个选项是关闭一个所有worker都接收的channel。这是一次向所有goroutine发送信号的简单方式。
package mainimport("fmt""sync")func main(){var wg sync.WaitGroupdone:= make(chan struct{}) workerCount :=2for i :=0; i < workerCount; i++{ wg.Add(1) go doit(i,done,wg)} close(done) wg.Wait() fmt.Println("all done!")}func doit(workerId int,done<-chan struct{},wg sync.WaitGroup){ fmt.Printf("[%v] is running\n",workerId) defer wg.Done()<-done fmt.Printf("[%v] is done\n",workerId)}复制代码如果你运行这个应用，你将会看到：
[0]is running[0]isdone[1]is running[1]isdone复制代码看起来所有的worker在主goroutine退出前都完成了。棒！然而，你也将会看到这个：
fatal error: all goroutines are asleep - deadlock!复制代码这可不太好 🙂 发送了神马？为什么会出现死锁？worker退出了，它们也执行了 wg.Done()。应用应该没问题啊。
死锁发生是因为各个worker都得到了原始的“WaitGroup”变量的一个拷贝。当worker执行 wg.Done()时，并没有在主goroutine上的“WaitGroup”变量上生效。
package mainimport("fmt""sync")func main(){var wg sync.WaitGroupdone:= make(chan struct{}) wq := make(chan interface{}) workerCount :=2for i :=0; i < workerCount; i++{ wg.Add(1) go doit(i,wq,done,&wg)}for i :=0; i < workerCount; i++{ wq <- i } close(done) wg.Wait() fmt.Println("all done!")}func doit(workerId int, wq <-chan interface{},done<-chan struct{},wg *sync.WaitGroup){ fmt.Printf("[%v] is running\n",workerId) defer wg.Done()for{select{case m :=<- wq: fmt.Printf("[%v] m => %v\n",workerId,m)case<-done: fmt.Printf("[%v] is done\n",workerId)return}}}复制代码现在它会如预期般工作 🙂
向无缓存的Channel发送消息，只要目标接收者准备好就会立即返回
- level: beginner
发送者将不会被阻塞，除非消息正在被接收者处理。根据你运行代码的机器的不同，接收者的goroutine可能会或者不会有足够的时间，在发送者继续执行前处理消息。
package mainimport"fmt"func main(){ ch := make(chan string) go func(){for m := range ch { fmt.Println("processed:",m)}}() ch <-"cmd.1" ch <-"cmd.2"//won't be processed}复制代码向已关闭的Channel发送会引起Panic
- level: beginner
从一个关闭的channel接收是安全的。在接收状态下的 ok的返回值将被设置为 false，这意味着没有数据被接收。如果你从一个有缓存的channel接收，你将会首先得到缓存的数据，一旦它为空，返回的 ok值将变为 false。
向关闭的channel中发送数据会引起panic。这个行为有文档说明，但对于新的Go开发者的直觉不同，他们可能希望发送行为与接收行为很像。
package mainimport("fmt""time")func main(){ ch := make(chan int)for i :=0; i <3; i++{ go func(idx int){ ch <-(idx +1)*2}(i)}//get the first result fmt.Println(<-ch) close(ch)//not ok (you still have other senders)//do other work time.Sleep(2* time.Second)}复制代码根据不同的应用，修复方法也将不同。可能是很小的代码修改，也可能需要修改应用的设计。无论是哪种方法，你都需要确保你的应用不会向关闭的channel中发送数据。
上面那个有bug的例子可以通过使用一个特殊的废弃的channel来向剩余的worker发送不再需要它们的结果的信号来修复。
package mainimport("fmt""time")func main(){ ch := make(chan int)done:= make(chan struct{})for i :=0; i <3; i++{ go func(idx int){select{case ch <-(idx +1)*2: fmt.Println(idx,"sent result")case<-done: fmt.Println(idx,"exiting")}}(i)}//get first result fmt.Println("result:",<-ch) close(done)//do other work time.Sleep(3* time.Second)}复制代码使用"nil" Channels
- level: beginner
在一个 nil的channel上发送和接收操作会被永久阻塞。这个行为有详细的文档解释，但它对于新的Go开发者而言是个惊喜。
package mainimport("fmt""time")func main(){var ch chan intfor i :=0; i <3; i++{ go func(idx int){ ch <-(idx +1)*2}(i)}//get first result fmt.Println("result:",<-ch)//do other work time.Sleep(2* time.Second)}复制代码如果运行代码你将会看到一个runtime错误：
fatal error: all goroutines are asleep - deadlock!复制代码这个行为可以在 select声明中用于动态开启和关闭 case代码块的方法。
package mainimport"fmt"import"time"func main(){ inch := make(chan int) outch := make(chan int) go func(){varin<- chan int= inch varout chan <-intvar val intfor{select{caseout<- val:out=nilin= inch case val =<-in:out= outch in=nil}}}() go func(){for r := range outch { fmt.Println("result:",r)}}() time.Sleep(0) inch <-1 inch <-2 time.Sleep(3* time.Second)}复制代码传值方法的接收者无法修改原有的值
- level: beginner
方法的接收者就像常规的函数参数。如果声明为值，那么你的函数/方法得到的是接收者参数的拷贝。这意味着对接收者所做的修改将不会影响原有的值，除非接收者是一个map或者slice变量，而你更新了集合中的元素，或者你更新的域的接收者是指针。
package mainimport"fmt"type data struct{ num int key *string items map[string]bool}func (this*data) pmethod(){this.num =7}func (this data) vmethod(){this.num =8*this.key ="v.key"this.items["vmethod"]=true}func main(){ key :="key.1" d := data{1,&key,make(map[string]bool)} fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items)//prints num=1 key=key.1 items=map[] d.pmethod() fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items)//prints num=7 key=key.1 items=map[] d.vmethod() fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items)//prints num=7 key=v.key items=map[vmethod:true]}复制代码原文地址: levy.at/blog/11
给这篇文章的作者打赏
文章来源：智云一二三科技
文章标题：Go的50坑：新Golang开发者要注意的陷阱、技巧和常见错误[1]
文章地址：https://www.zhihuclub.com/391.shtml
