四、for和range几个“神奇”的问题

1. 循环永动机

func main() {
	arr := []int{1, 2, 3}
	for _, v := range arr { 
		arr = append(arr, v) // 遍历arr的时候，向arr增加元素
	}
	fmt.Println(arr)
}

$ go run main.go
1 2 3 1 2 3

        上述代码的输出意味着循环只遍历了原始切片中的3个元素，我们在遍历切片时追加的元素不会增加循环的执行次数，所以循环最终还是停了下来

        遍历的底层原理：对于所有的 range 循环，Go 语言都会在编译期将原切片或者数组赋值给一个新变量 ha，在赋值的过程中就发生了拷贝，而我们又通过 len 关键字预先获取了切片的长度，所以在循环中追加新的元素也不会改变循环执行的次数，这也就解释了循环永动机一节提到的现象

ha := a
hv1 := 0
hn := len(ha)
v1 := hv1
for ; hv1 < hn; hv1++ {
    v1 = hv1
    ...
}

2. 神奇的指针

func main() {
	arr := []int{1, 2, 3}
	newArr := []*int{}
	for _, v := range arr {
		newArr = append(newArr, &v)
	}
	for _, v := range newArr {
		fmt.Println(*v)
	}
}

$ go run main.go
3 3 3

说明：一些有经验的开发者不经意也会犯这种错误，正确的做法应该是使用 &arr[i] 替代 &v

ha := a
hv1 := 0
hn := len(ha)
v1 := hv1
v2 := nil
for ; hv1 < hn; hv1++ {
    tmp := ha[hv1]
    v1, v2 = hv1, tmp
    ...
}

        而遇到这种同时遍历索引和元素的 range 循环时，Go 语言会额外创建一个新的 v2 变量存储切片中的元素，循环中使用的这个变量 v2 会在每一次迭代被重新赋值而覆盖，赋值时也会触发拷贝。

        因为在循环中获取返回变量的地址都完全相同，所以会发生神奇的指针一节中的现象。因此当我们想要访问数组中元素所在的地址时，不应该直接获取 range 返回的变量地址 &v2，而应该使用 &a[index] 这种形式

3. Map遍历的值是随机的

func main() {
	hash := map[string]int{
		"1": 1,
		"2": 2,
		"3": 3,
	}
	for k, v := range hash {
		println(k, v)
	}
}
$ go run main.go
2 2
3 3
1 1

$ go run main.go
1 1
2 2
3 3

         两次运行上述代码可能会得到不同的结果，第一次会打印 2 3 1，第二次会打印 1 2 3，如果我们运行的次数足够多，最后会得到几种不同的遍历顺序。

原理

1. 首先生成一个随机数帮助我们随机选择一个遍历桶的起始位置。Go 团队在设计哈希表的遍历时就不想让使用者依赖固定的遍历顺序，所以引入了随机数保证遍历的随机性。

2. 选择桶

        首先会选出一个绿色的正常桶开始遍历，随后遍历所有黄色的溢出桶，最后依次按照索引顺序遍历哈希表中其他的桶，直到所有的桶都被遍历完成

map 循环是有序的还是无序的？答：无序的，map 因扩张⽽重新哈希时，各键值项存储位置都可能会发生改变，顺序自然也没法保证了，所以官方避免大家依赖顺序，直接打乱处理。就是 for range map 在开始处理循环逻辑的时候，就做了随机播种

五、defer

作用：延迟函数，释放资源、收尾工作

1. 调用顺序：后进先出

2. 执行顺序：defer、return，return value（函数返回值）

func b() (i int) {
	defer func() {
		i++
		fmt.Println("defer2:", i)
	}()
	defer func() {
		i++
		fmt.Println("defer1:", i)
	}()
	return i //或者直接写成return
}
func main() {
	fmt.Println("return:", b())
}

defer1: 1
defer2: 2
return: 2

3. defer底层的数据结构

        1. 每个defer都对应一个_defer实例，多个实例通过指针串联成一个单链表，保存在gotoutine数据结构中

        2. 每次插入_defer实例，均头插；函数结束也是从链表头部去除开始

六、反射？

反射的作用，就是把类型元数据暴露给用户使用

Go 中解析的 tag 是通过反射实现的，反射是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力或动态知道给定数据对象的类型和结构，并有机会修改它。反射将接口变量转换成反射对象 Type 和 Value；反射可以通过反射对象 Value 还原成原先的接口变量；反射可以用来修改一个变量的值，前提是这个值可以被修改；

TypeOf 获取一个变量的类型信息 func TypeOf(i interface{}) Type

ValueOf 获取变量的值

七、多路Select

        select结构组成主要是由case语句和执行的函数组成的，select的case和switch不同，只能处理channel。

        1. select仅支持channel

        2. select出现读写nil的channel，该分支会被忽略

        3. 每个case只能处理一个channel，要么读要么写

        4. select 在遇到多个 Channel 同时响应时，会随机执行一种情况

        5. 存在default语句，select将不会阻塞

八、闭包

        有人形象的概括闭包就是：函数 + 引用环境 = 闭包，要搞清楚闭包的关键就是分析出返回的函数和它引用到哪些变量

说到Go语言的闭包，不得不说说全局变量和局部变量

        全局变量的特点：1.常驻内存  2. 污染全局
        局部变量的特点：1.不常驻内存  2.不污染全局

而Go语言的闭包可以做到：1.可以让变量常驻内存  2.可以让变量不污染全局 ===> 所以闭包主要是为了避免全局变量的滥用

闭包：
        1.闭包是指有权访问另一个函数作用域中的变量的函数==>包括自由变量（在函数外部定义但在函数内被引用）
        2.创建闭包的常见方式就是在一个函数内部创建另一个函数， 内函数可以访问外函数的变量 ==> 即使脱离了捕捉时的上下文，它也能照样执行

注意：
      闭包里作用域返回的局部变量不会被立刻销毁回收，但过度使用闭包可能会占用更多内存，导致性能下降

例子1

// 函数create()的返回值是一个函数func() int
func create() func() int {
	c := 2              // 通常称这个变量为"捕获变量"
	return func() int { // 该函数使用了外部定义的变量c
		return c
	}
}
func main() {
	// 即使create()结束，通过f1和f2依然能够正常调用这个闭包函数，并使用在create()函数内部定义的局部变量c
	f1 := create()
	f2 := create()
	fmt.Println(f1(), f2()) // 2 2
}

例子2

1. addTool是一个函数，返回的数据类型是func(int)int
2. 这个匿名函数就和变量n形成一个整体，构成闭包。大家可以这样理解：闭包是类，函数是操作，n是字段，函数和它使用的变量构成闭包
3. 当我们反复调用f函数时，因为n是初始化一次，因此每调用一次就进行累计

func addTool() func(int) int {
	var n = 10
	return func(x int) int { // 闭包
		n = n + x
		return n
	}
}
func main() {
	f := addTool()
	fmt.Println(f(1)) // 11
	fmt.Println(f(2)) // 13
	fmt.Println(f(3)) // 16
}

九、context 上下文

先来几个问答

Q1：context设计成线程安全？

A1：不同协程通过channel进行通信，本身的使用场景就是多线程，为了保证数据的一致性，必须实现线程安全

Q2：如何实现线程安全的？

A2：channel的底层实现中，hchan结构体中采用mutex锁来保证数据读写安全。在对循环数组buf中的数据进行入队和出队操作时，必须先获取mutex，才能操作channel数据

应用场景：在多个协程之间，传递截止时间、取消信号、请求相关的数据

context概括为：1个接口，4种实现，6个函数  

9.1. 一个接口

type Context interface {
	Deadline() (deadline time.Time, ok bool)
	Done() <-chan struct{}
	Err() error
	Value(key interface{}) interface{}
}

Deadline()：返回值(deadline time.Time, ok bool)

        1. ok：表示有结束时间，否则表示无结束时间

        2. time.Time：表示context的截止时间，通过此时间，函数就可以决定是否进行接下来的操作：①如果时间太短，就可以不往下面做了，否则浪费系统资源 ②也可以使用这个deadline来设置一个IO操作的超时时间

Done()

        1. 返回一个只读的chan，类型为struct{}

        2. 在goroutine中，如果该方法返回的chan可以读取，则意味着parent context已经发起了取消请求，通过Done方法收到这个信号后，就应该做清理操作，然后退出goroutine，释放资源

Err()：返回一个错误，表示channel被关闭的原因，例如：被取消、超时等

Value()：Value方法获取该Context上绑定的值，是一个键值对，所以要通过一个Key才可以获取对应的值，这个值一般是线程安全的

9.2. 四种实现 + 六个函数

9.2.1. emptyCtx

        emptyCtx对context的实现，只是简单的返回nil、false，实际上什么也没做

9.2.2. cancelCtx — 可取消的context

type cancelCtx struct {
	Context
	mu       sync.Mutex            
	done     chan struct{}         // 用于获取该context的取消通知
	children map[canceler]struct{} // 用于存储以当前节点为根节点的所有可取消的context
	err      error                 // 存储取消时指定的错误信息
}

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) 

作用：将context包装成cancelCtx，并提供一个取消函数cancel，调用它可以cancel对应的context

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go func(ctx context.Context) {
		for {
			select {
			case <-ctx.Done():
				fmt.Println("监控退出，停止了...")
				return
			default:
				fmt.Println("goroutine监控中...")
				time.Sleep(2 * time.Second)
			}
		}
	}(ctx)

	time.Sleep(10 * time.Second)
	fmt.Println("可以了，通知监控停止")
	cancel()
	//为了检测监控过是否停止，如果没有监控输出，就表示停止了
	time.Sleep(5 * time.Second)
}

9.2.3. timerCtx — 超时取消的context

        timerCtx是在cancelCtx基础上，增加了定时器/截止时间功能，这样，①既可以根据需要主动取消，②也可以到达deadline时，通过timer来调用cancelCtx的取消函数

type timerCtx struct {
	*cancelCtx
	timer *time.Timer  // 定时器
	deadline time.Time // 截止时间
}

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

作用：创建timerCtx对象，指定时间段

        
func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc) 

作用：创建timerCtx对象，指定时间点

9.2.3. valueCtx — 支持键值对打包        

  给context附加一个键值对信息，支持context传递数据

十、channel

10.1. 底层实现原理（数据结构）

        环形数组/读写下标：buf、sendx、recvx

        goroutine队列：sendq等待写消息的 goroutine 队列、recvq等待读消息的 goroutine 队列

        互斥锁：lock

10.2. 案例分析

1. 创建一个具有5个缓冲区的channel

2. 协程G1向channel写入1,2,3,4,5,6，写入1~5时，不会发生阻塞，缓冲区被写满

3. 当写入6时，因为缓冲区满了，所以6无处可放，此时协程G1就会加入到sendq中。sudog是协程队列中的元素结构体，g保存了协程、elem保存了等待发送的数据6、c保存了阻塞在哪个chan

4. 当开了协程G2去channel读取数据，recvx下标向前移动

5. 此时，因为缓冲区buf中存在空闲位置了，所以会去唤醒sendq中的发送协程G1，G1会将数据发送给缓冲区buf

6. 缓冲区buf再次满了，G1继续挂起，保存在recvq中，循环执行上面步骤... ...

10.3. 总结

向channel发送数据

是否阻塞取决于2个条件：① recvq中是否有消费者 ②buf是否为空

        如果channel的recvq存在接收者goroutine：将数据直接发送给第一个等待的goroutine，唤醒接收的goroutine

        如果channel的recvq不存在接收者goroutine：

                1. 如果循环数组buf未满，那么将会把数据发送到buf的队尾

                2. 如果循环数组buf已满，此时就会走阻塞发送的流程，将当前发送数据的goroutine加入sendq（不让其发送数据），并挂起等待唤醒

从channel接收数据

是否阻塞取决于2个条件：① sendq中是否有生产者 ②buf是否为空

        如果channel的sendq存在发送者goroutine

                1. 如果是无缓冲channel，直接从第一个发送者goroutine哪里把数据拷贝给接收变量，唤醒发送的goroutine

                2. 如果是有缓冲channel（已满），将循环数组buf的队首元素拷贝给接收变量，将第一个发送者goroutine的数据拷贝到buf队尾，唤醒发送的goroutine

        如果channel的sendq不存在发送者goroutine

                1. 如果buf非空，将循环数组buf的队首元素拷贝给接收变量

                2. 如果buf为空，这个时候就会走阻塞接收的流程，将当前goroutine加入readq，并挂起等待唤醒

10.4. 使用案例+注意事项

channel有2种类型：无缓冲、有缓冲

channel有3种模式：写操作模式（单向通道）、读操作模式（单向通道）、读写模式（双向通道）

创建
make(chan <-int) // 写操作模式
make(<-chan int) // 读操作模式
make(chan int)   // 读写操作模式

注意点：

1. 一个channel不能多次关闭，会导致panic

2. 若多个goroutine都监听同一个channel，那么channel上的数据都可能随机被某一个goroutine取走进行消费

3. 若多个goroutine监听同一个channel，如果这个channel被关闭，则所有goroutine都能收到退出信号