Go语言面试遇到，面试官问什么是协程、什么是协程泄漏和数组跟切片是用该如何回答

什么是协程？

"协程，我把它理解为用户态的轻量级线程。它和线程最大的区别在于：线程的调度由操作系统内核负责，切换时涉及内核态和用户态的切换，开销比较大；而协程的调度完全在用户态完成，由程序自己控制什么时候挂起、什么时候恢复，因此切换成本极低。

从本质上讲，协程是一种可暂停、可恢复的函数。普通函数一旦执行就一路到底，中间没法停下来让给别人；但协程可以在执行到一半时主动让出执行权（比如遇到 I/O 等待），等条件满足了再回到刚才的断点继续往下跑。

什么是协程泄漏？

"协程泄漏，简单说就是：协程没有正常结束，但它的引用已经丢了，或者说它一直被阻塞在某个地方永远等不到结果，导致占用的内存和其他资源无法释放。

和内存泄漏类比：内存泄漏是’分配了内存忘了 free’，协程泄漏就是’创建了协程忘了（或者说没法）让它正常结束’。

举个例子，我启动了一个协程去等待一个网络请求的超时结果，但这个请求的 future 永远没有被 resolve 也没有被 cancel，那么这个协程就会一直挂在那里——它占着栈空间和闭包引用的变量，GC 也无法回收，随着时间推移越积越多，最终撑爆内存或端口耗尽。"

场景一：永不关闭的 channel

// ❌ 泄漏：ch 永远没人发也不关闭，这个 goroutine 永远阻塞 func leak() { ch := make(chan int) go func() { val := <-ch // 永远在这儿等着 fmt.Println(val) }() // 函数返回了，但上面的 goroutine 还活着 }

场景二：往没人读的 channel 发数据

// ❌ 泄漏：goroutine 想往 channel 发数据，但没人接 func leak() { ch := make(chan int) // 无缓冲！ go func() { ch <- 42 // 永远阻塞，因为没人来读 }() }

场景三：for-range 未关闭的 channel

// ❌ 泄漏：channel 不 close，range 就永远不会结束 func leak() { ch := make(chan int) go func() { for val := range ch { // ch 一直开着，range 出不去 fmt.Println(val) } }() }

场景四：select 缺少退出通道

// ❌ 泄漏：select 没有 case 能退出 func leak(ctx context.Context) { ch := make(chan int) go func() { for { select { case v := <-ch: handle(v) // 少了 case <-ctx.Done(): return ！ } } }() }

场景五：http.Client 不读 Body

// ❌ 经典泄漏：http.Get 之后没读也没关 Body，连接无法复用 func leak() { for { resp, _ := http.Get("https://example.com") // 忘了 resp.Body.Close() → goroutine 泄漏 + 连接泄漏 } }

什么是数组？

"Go 的数组是一块固定长度、类型确定的连续内存区域。长度是类型的一部分——[3]int和[5]int在 Go 眼里是完全不同的类型，不能互相赋值。

核心特点就三点：

• 长度固定，编译期就确定了，之后不能变
• 值类型，赋值或传参会发生整体拷贝，不是传引用
• 内存连续，所有元素紧挨着放在一起，CPU 缓存友好

举个例子：

var arr [3]int = [3]int{1, 2, 3} arr2 := arr // 整个数组拷贝了一份，arr 和 arr2 互不影响 arr2[0] = 99 // arr 还是 [1, 2, 3]

实际开发中，我几乎不会直接用[N]T这种数组。它更多出现在底层——比如[32]byte出现在 SHA256 的返回类型里，或者作为切片的底层存储。"

什么是切片？

"切片是对数组的一个动态视图。它本身不存数据，存的是三样东西：指向底层数组某个位置的指针、长度（len）、容量（cap）。

type slice struct { ptr *Element // 指向底层数组的指针 len int // 当前有多少个元素 cap int // 从 ptr 开始到数组末尾还能装多少个 }

因为这个设计，切片有几个重要行为：

• 它是引用语义——赋值或传参只拷贝 slice header（24 字节），不拷贝底层数据
• append 扩容：当 len == cap 时，append 会分配一块更大的新底层数组，把旧数据拷过去，返回新切片
• 通过make([]T, len, cap)可以预分配容量，避免频繁扩容

切片是我在 Go 里最常用的数据结构，基本取代了数组。函数传参、返回集合、处理子串，全是切片。"

区别是什么？

例子一：值拷贝 vs 引用语义

// 数组：值拷贝，互不影响 arr1 := [3]int{1, 2, 3} arr2 := arr1 arr2[0] = 999 fmt.Println(arr1[0]) // 1 ← 没变！ // 切片：共享底层数组 s1 := []int{1, 2, 3} s2 := s1 s2[0] = 999 fmt.Println(s1[0]) // 999 ← 变了！

例子二：函数传参

// ❌ 数组传参：100万 int 全拷贝，4MB 复制！ func sumArray(arr [1000000]int) int { ... } // ✅ 切片传参：只传 24 字节 func sumSlice(s []int) int { ... }

例子三：append 的陷阱

s1 := make([]int, 0, 3) s2 := s1 s2 = append(s2, 1, 2, 3) // 还在 cap 之内，s1 底层数组也变了 s2 = append(s2, 4) // 超 cap，扩容了！s2 换新底层数组，s1 不受影响