常见的控制结构，比如defer、select、range等，通过对其底层实现原理的分析，来加深认识，以此避免一些使用过程中的误区。
defer语句用于延迟函数的调用，每次defer都会把一个函数压入栈中，函数返回前再把延迟的函数取出并执行。
为了方便描述，我们把创建defer的函数称为主函数，defer语句后面的函数称为延迟函数。
延迟函数可能有输入参数，这些参数可能来源于定义defer的函数，延迟函数也可能引用主函数用于返回的变量，也就是说延迟函数可能会影响主函数的一些行为，这些场景下，如果不了解defer的规则很容易出错。
其实官方说明的defer的三个原则很清楚，本节试图汇总defer的使用场景并做简单说明。
defer
热身
按照惯例，我们看几个有意思的题目，用于检验对defer的了解程度。
题目1
下面函数输出结果是什么？
func deferFuncParameter() {
var aInt = 1
defer fmt.Println(aInt)
aInt = 2
return
} 题目说明：
函数deferFuncParameter()定义一个整型变量并初始化为1，然后使用defer语句打印出变量值，最后修改变量值为2.
参考答案：
输出1。延迟函数fmt.Println(aInt)的参数在defer语句出现时就已经确定了，所以无论后面如何修改aInt变量都不会影响延迟函数。
题目2
下面程序输出什么？
package main
import "fmt"
func printArray(array *[3]int) {
for i := range array {
fmt.Println(array[i])
}
}
func deferFuncParameter() {
var aArray = [3]int{1, 2, 3}
defer printArray(&aArray)
aArray[0] = 10
return
}
func main() {
deferFuncParameter()
} 函数说明：
函数deferFuncParameter()定义一个数组，通过defer延迟函数printArray()的调用，最后修改数组第一个元素。printArray()函数接受数组的指针并把数组全部打印出来。
参考答案：
输出10、2、3三个值。延迟函数printArray()的参数在defer语句出现时就已经确定了，即数组的地址，由于延迟函数执行时机是在return语句之前，所以对数组的最终修改值会被打印出来。
题目3
下面函数输出什么？
func deferFuncReturn() (result int) {
i := 1
defer func() {
result++
}()
return i
} 函数说明：
函数拥有一个具名返回值result，函数内部声明一个变量i，defer指定一个延迟函数，最后返回变量i。延迟函数中递增result。
参考答案：
函数输出2。函数的return语句并不是原子的，实际执行分为设置返回值—>ret，defer语句实际执行在返回前，即拥有defer的函数返回过程是：设置返回值—>执行defer—>ret。所以return语句先把result设置为i的值，即1，defer语句中又把result递增1，所以最终返回2。
defer规则
Golang官方博客里总结了defer的行为规则，只有三条，我们围绕这三条进行说明。
规则一：延迟函数的参数在defer语句出现时就已经确定下来了
官方给出一个例子，如下所示：
func a() {
i := 0
defer fmt.Println(i)
i++
return
} defer语句中的fmt.Println()参数i值在defer出现时就已经确定下来，实际上是拷贝了一份。后面对变量i的修改不会影响fmt.Println()函数的执行，仍然打印”0”。
注意：对于指针类型参数，规则仍然适用，只不过延迟函数的参数是一个地址值，这种情况下，defer后面的语句对变量的修改可能会影响延迟函数。
规则二：延迟函数执行按后进先出顺序执行，即先出现的defer最后执行
这个规则很好理解，定义defer类似于入栈操作，执行defer类似于出栈操作。
设计defer的初衷是简化函数返回时资源清理的动作，资源往往有依赖顺序，比如先申请A资源，再跟据A资源申请B资源，跟据B资源申请C资源，即申请顺序是:A—>B—>C，释放时往往又要反向进行。这就是把deffer设计成FIFO的原因。
每申请到一个用完需要释放的资源时，立即定义一个defer来释放资源是个很好的习惯。
规则三：延迟函数可能操作主函数的具名返回值
定义defer的函数，即主函数可能有返回值，返回值有没有名字没有关系，defer所作用的函数，即延迟函数可能会影响到返回值。
若要理解延迟函数是如何影响主函数返回值的，只要明白函数是如何返回的就足够了。
函数返回过程
有一个事实必须要了解，关键字 return 不是一个原子操作，实际上 return 只代理汇编指令 ret ，即将跳转程序执行。比如语句 return i ，实际上分两步进行，即将i值存入栈中作为返回值，然后执行跳转，而defer的执行时机正是跳转前，所以说defer执行时还是有机会操作返回值的。
举个实际的例子进行说明这个过程：
func deferFuncReturn() (result int) {
i := 1
defer func() {
result++
}()
return i
} 该函数的return语句可以拆分成下面两行：
result = i
return 而延迟函数的执行正是在return之前，即加入defer后的执行过程如下：
result = i
result++
return 所以上面函数实际返回i++值。
关于主函数有不同的返回方式，但返回机制就如上文介绍所说，只要把return语句拆开都可以很好地理解，下面分别举例说明
主函数拥有匿名返回值，返回字面值
一个主函数拥有一个匿名的返回值，返回时使用字面值，比如返回”1”、”2”、”Hello”这样的值，这种情况下defer语句是无法操作返回值的。
一个返回字面值的函数，如下所示：
func foo() int {
var i int
defer func() {
i++
}()
return 1
} 上面的return语句，直接把1写入栈中作为返回值，延迟函数无法操作该返回值，所以就无法影响返回值。
主函数拥有匿名返回值，返回变量
一个主函数拥有一个匿名的返回值，返回使用本地或全局变量，这种情况下defer语句可以引用到返回值，但不会改变返回值。
一个返回本地变量的函数，如下所示：
func foo() int {
var i int
defer func() {
i++
}()
return i
} 上面的函数，返回一个局部变量，同时defer函数也会操作这个局部变量。对于匿名返回值来说，可以假定仍然有一个变量存储返回值，假定返回值变量为”anony”，上面的返回语句可以拆分成以下过程：
anony = i
i++
return 由于i是整型，会将值拷贝给anony，所以defer语句中修改i值，对函数返回值不造成影响。
主函数拥有具名返回值
主函声明语句中带名字的返回值，会被初始化成一个局部变量，函数内部可以像使用局部变量一样使用该返回值。如果defer语句操作该返回值，可能会改变返回结果。
一个影响函返回值的例子：
func foo() (ret int) {
defer func() {
ret++
}()
return 0
} 上面的函数拆解出来，如下所示：
ret = 0
ret++
return 函数真正返回前，在defer中对返回值做了+1操作，所以函数最终返回1。
defer实现原理
本节我们尝试了解一些defer的实现机制。
defer数据结构
源码包 src/src/runtime/runtime2.go:_defer 定义了defer的数据结构：
type _defer struct {
sp uintptr //函数栈指针
pc uintptr //程序计数器
fn *funcval //函数地址
link *_defer //指向自身结构的指针，用于链接多个defer
} 我们知道defer后面一定要接一个函数的，所以defer的数据结构跟一般函数类似，也有栈地址、程序计数器、函数地址等等。
与函数不同的一点是它含有一个指针，可用于指向另一个defer，每个goroutine数据结构中实际上也有一个defer指针，该指针指向一个defer的单链表，每次声明一个defer时就将defer插入到单链表表头，每次执行defer时就从单链表表头取出一个defer执行。
下图展示多个defer被链接的过程：
从上图可以看到，新声明的defer总是添加到链表头部。
函数返回前执行defer则是从链表首部依次取出执行，不再赘述。
一个goroutine可能连续调用多个函数，defer添加过程跟上述流程一致，进入函数时添加defer，离开函数时取出defer，所以即便调用多个函数，也总是能保证defer是按FIFO方式执行的。
defer的创建和执行
源码包 src/runtime/panic.go 定义了两个方法分别用于创建defer和执行defer。
- deferproc()： 在声明defer处调用，其将defer函数存入goroutine的链表中；
- deferreturn()：在return指令，准确地讲是在ret指令前调用，其将defer从goroutine链表中取出并执行。
可以简单这么理解，在编译在阶段，声明defer处插入了函数deferproc()，在函数return前插入了函数deferreturn()。
总结
- defer定义的延迟函数参数在defer语句出时就已经确定下来了
- defer定义顺序与实际执行顺序相反
- return不是原子操作，执行过程是: 保存返回值(若有)—>执行defer（若有）—>执行ret跳转
- 申请资源后立即使用defer关闭资源是好习惯
select
select是Golang在语言层面提供的多路IO复用的机制，其可以检测多个channel是否ready(即是否可读或可写)，使用起来非常方便。
根据源码总结其实现原理，从而发现一些使用误区或解释一些不太常见的现象。
热身环节
我们先看几个题目，用于测试对select的了解程度，每个题目代表一个知识点，后面的部分会进行略为详细的介绍。
题目1
下面的程序输出是什么？
package main
import (
"fmt"
"time"
)
func main() {
chan1 := make(chan int)
chan2 := make(chan int)
go func() {
chan1 <- 1
time.Sleep(5 * time.Second)
}()
go func() {
chan2 <- 1
time.Sleep(5 * time.Second)
}()
select {
case <-chan1:
fmt.Println("chan1 ready.")
case <-chan2:
fmt.Println("chan2 ready.")
default:
fmt.Println("default")
}
fmt.Println("main exit.")
} 程序中声明两个channel，分别为chan1和chan2，依次启动两个协程，分别向两个channel中写入一个数据就进入睡眠。select语句两个case分别检测chan1和chan2是否可读，如果都不可读则执行default语句。
参考答案：select中各个case执行顺序是随机的，如果某个case中的channel已经ready，则执行相应的语句并退出select流程，如果所有case中的channel都未ready，则执行default中的语句然后退出select流程。另外，由于启动的协程和select语句并不能保证执行顺序，所以也有可能select执行时协程还未向channel中写入数据，所以select直接执行default语句并退出。所以，以下三种输出都有可能：
可能的输出一：
chan1 ready.
main exit. 可能的输出二：
chan2 ready.
main exit. 可能的输出三：
default
main exit. 题目2
下面的程序执行到select时会发生什么？
package main
import (
"fmt"
"time"
)
func main() {
chan1 := make(chan int)
chan2 := make(chan int)
writeFlag := false
go func() {
for {
if writeFlag {
chan1 <- 1
}
time.Sleep(time.Second)
}
}()
go func() {
for {
if writeFlag {
chan2 <- 1
}
time.Sleep(time.Second)
}
}()
select {
case <-chan1:
fmt.Println("chan1 ready.")
case <-chan2:
fmt.Println("chan2 ready.")
}
fmt.Println("main exit.")
} 程序中声明两个channel，分别为chan1和chan2，依次启动两个协程，协程会判断一个bool类型的变量writeFlag来决定是否要向channel中写入数据，由于writeFlag永远为false，所以实际上协程什么也没做。select语句两个case分别检测chan1和chan2是否可读，这个select语句不包含default语句。
参考答案：select会按照随机的顺序检测各case语句中channel是否ready，如果某个case中的channel已经ready则执行相应的case语句然后退出select流程，如果所有的channel都未ready且没有default的话，则会阻塞等待各个channel。所以上述程序会一直阻塞。
题目3
下面程序有什么问题？
package main
import (
"fmt"
)
func main() {
chan1 := make(chan int)
chan2 := make(chan int)
go func() {
close(chan1)
}()
go func() {
close(chan2)
}()
select {
case <-chan1:
fmt.Println("chan1 ready.")
case <-chan2:
fmt.Println("chan2 ready.")
}
fmt.Println("main exit.")
} 程序中声明两个channel，分别为chan1和chan2，依次启动两个协程，协程分别关闭两个channel。select语句两个case分别检测chan1和chan2是否可读，这个select语句不包含default语句。
参考答案：select会按照随机的顺序检测各case语句中channel是否ready，考虑到已关闭的channel也是可读的，所以上述程序中select不会阻塞，具体执行哪个case语句具是随机的。
题目4
下面程序会发生什么？
package main
func main() {
select {
}
} 上面程序中只有一个空的select语句。
参考答案：对于空的select语句，程序会被阻塞，准确的说是当前协程被阻塞，同时Golang自带死锁检测机制，当发现当前协程再也没有机会被唤醒时，则会panic。所以上述程序会panic。
实现原理
Golang实现select时，定义了一个数据结构表示每个case语句(含defaut，default实际上是一种特殊的case)，select执行过程可以类比成一个函数，函数输入case数组，输出选中的case，然后程序流程转到选中的case块。
case数据结构
源码包 src/runtime/select.go:scase 定义了表示case语句的数据结构：
type scase struct {
c *hchan // chan
kind uint16
elem unsafe.Pointer // data element
} scase.c为当前case语句所操作的channel指针，这也说明了一个case语句只能操作一个channel。scase.kind表示该case的类型，分为读channel、写channel和default，三种类型分别由常量定义：
- caseRecv：case语句中尝试读取scase.c中的数据；
- caseSend：case语句中尝试向scase.c中写入数据；
- caseDefault： default语句
scase.elem表示缓冲区地址，跟据scase.kind不同，有不同的用途：
- scase.kind == caseRecv ： scase.elem表示读出channel的数据存放地址；
- scase.kind == caseSend ： scase.elem表示将要写入channel的数据存放地址；
select实现逻辑
源码包 src/runtime/select.go:selectgo() 定义了select选择case的函数：
func selectgo(cas0 *scase, order0 *uint16, ncases int) (int, bool) 函数参数：
- cas0为scase数组的首地址，selectgo()就是从这些scase中找出一个返回。
- order0为一个两倍cas0数组长度的buffer，保存scase随机序列pollorder和scase中channel地址序列lockorderpollorder：每次selectgo执行都会把scase序列打乱，以达到随机检测case的目的。lockorder：所有case语句中channel序列，以达到去重防止对channel加锁时重复加锁的目的。
- ncases表示scase数组的长度
函数返回值：
- int： 选中case的编号，这个case编号跟代码一致
- bool: 是否成功从channle中读取了数据，如果选中的case是从channel中读数据，则该返回值表示是否读取成功。
selectgo实现伪代码如下：
func selectgo(cas0 *scase, order0 *uint16, ncases int) (int, bool) {
//1. 锁定scase语句中所有的channel
//2. 按照随机顺序检测scase中的channel是否ready
// 2.1 如果case可读，则读取channel中数据，解锁所有的channel，然后返回(case index, true)
// 2.2 如果case可写，则将数据写入channel，解锁所有的channel，然后返回(case index, false)
// 2.3 所有case都未ready，则解锁所有的channel，然后返回（default index, false）
//3. 所有case都未ready，且没有default语句
// 3.1 将当前协程加入到所有channel的等待队列
// 3.2 当将协程转入阻塞，等待被唤醒
//4. 唤醒后返回channel对应的case index
// 4.1 如果是读操作，解锁所有的channel，然后返回(case index, true)
// 4.2 如果是写操作，解锁所有的channel，然后返回(case index, false)
} 特别说明：对于读channel的case来说，如 case elem, ok := <-chan1: , 如果channel有可能被其他协程关闭的情况下，一定要检测读取是否成功，因为close的channel也有可能返回，此时ok == false。
总结
- select语句中除default外，每个case操作一个channel，要么读要么写
- select语句中除default外，各case执行顺序是随机的
- select语句中如果没有default语句，则会阻塞等待任一case
- select语句中读操作要判断是否成功读取，关闭的channel也可以读取
range
range是Golang提供的一种迭代遍历手段，可操作的类型有数组、切片、Map、channel等，实际使用频率非常高。
探索range的实现机制是很有意思的事情，这可能会改变你使用range的习惯。
热身
按照惯例，我们看几个有意思的题目，用于检测对range的了解程度。
题目1：切片遍历
下面函数通过遍历切片，打印切片的下标和元素值，请问性能上有没有可优化的空间？
func RangeSlice(slice []int) {
for index, value := range slice {
_, _ = index, value
}
} 程序解释：函数中使用for-range对切片进行遍历，获取切片的下标和元素素值，这里忽略函数的实际意义。
参考答案：遍历过程中每次迭代会对index和value进行赋值，如果数据量大或者value类型为string时，对value的赋值操作可能是多余的，可以在for-range中忽略value值，使用slice[index]引用value值。
题目2：Map遍历
下面函数通过遍历Map，打印Map的key和value，请问性能上有没有可优化的空间？
func RangeMap(myMap map[int]string) {
for key, _ := range myMap {
_, _ = key, myMap[key]
}
} 程序解释：函数中使用for-range对map进行遍历，获取map的key值，并根据key值获取获取value值，这里忽略函数的实际意义。
参考答案：函数中for-range语句中只获取key值，然后根据key值获取value值，虽然看似减少了一次赋值，但通过key值查找value值的性能消耗可能高于赋值消耗。能否优化取决于map所存储数据结构特征、结合实际情况进行。
题目3：动态遍历
请问如下程序是否能正常结束？
func main() {
v := []int{1, 2, 3}
for i:= range v {
v = append(v, i)
}
} 程序解释：main()函数中定义一个切片v，通过range遍历v，遍历过程中不断向v中添加新的元素。
参考答案：能够正常结束。循环内改变切片的长度，不影响循环次数，循环次数在循环开始前就已经确定了。
实现原理
对于for-range语句的实现，可以从编译器源码中找到答案。编译器源码 gofrontend/go/statements.cc/For_range_statement::do_lower() 方法中有如下注释。
// Arrange to do a loop appropriate for the type. We will produce
// for INIT ; COND ; POST {
// ITER_INIT
// INDEX = INDEX_TEMP
// VALUE = VALUE_TEMP // If there is a value
// original statements
// } 可见range实际上是一个C风格的循环结构。range支持数组、数组指针、切片、map和channel类型，对于不同类型有些细节上的差异。
range for slice
下面的注释解释了遍历slice的过程：
// The loop we generate:
// for_temp := range
// len_temp := len(for_temp)
// for index_temp = 0; index_temp < len_temp; index_temp++ {
// value_temp = for_temp[index_temp]
// index = index_temp
// value = value_temp
// original body
// } 遍历slice前会先获以slice的长度len_temp作为循环次数，循环体中，每次循环会先获取元素值，如果for-range中接收index和value的话，则会对index和value进行一次赋值。
由于循环开始前循环次数就已经确定了，所以循环过程中新添加的元素是没办法遍历到的。
另外，数组与数组指针的遍历过程与slice基本一致，不再赘述。
range for map
下面的注释解释了遍历map的过程：
// The loop we generate:
// var hiter map_iteration_struct
// for mapiterinit(type, range, &hiter); hiter.key != nil; mapiternext(&hiter) {
// index_temp = *hiter.key
// value_temp = *hiter.val
// index = index_temp
// value = value_temp
// original body
// } 遍历map时没有指定循环次数，循环体与遍历slice类似。由于map底层实现与slice不同，map底层使用hash表实现，插入数据位置是随机的，所以遍历过程中新插入的数据不能保证遍历到。
range for channel
遍历channel是最特殊的，这是由channel的实现机制决定的：
// The loop we generate:
// for {
// index_temp, ok_temp = <-range
// if !ok_temp {
// break
// }
// index = index_temp
// original body
// } channel遍历是依次从channel中读取数据,读取前是不知道里面有多少个元素的。如果channel中没有元素，则会阻塞等待，如果channel已被关闭，则会解除阻塞并退出循环。
注：
- 上述注释中index_temp实际上描述是有误的，应该为value_temp，因为index对于channel是没有意义的。
- 使用for-range遍历channel时只能获取一个返回值。
编程Tips
- 遍历过程中可以视当情况放弃接收index或value，可以一定程度上提升性能
- 遍历channel时，如果channel中没有数据，可能会阻塞
- 尽量避免遍历过程中修改原数据
总结
- for-range的实现实际上是C风格的for循环
- 使用index,value接收range返回值会发生一次数据拷贝
