【Golang 面试 - 进阶题】每日 3 题（五）

✍个人博客：Pandaconda-CSDN博客

📣专栏地址：http://t.csdnimg.cn/UWz06

📚专栏简介：在这个专栏中，我将会分享 Golang 面试中常见的面试题给大家~

❤️如果有收获的话，欢迎点赞👍收藏📁，您的支持就是我创作的最大动力💪

13. Cond 中 Wait 使用

在 Go 语言中，sync.Cond 类型提供了 Wait() 方法来让 Goroutine 等待条件变量。当 Goroutine 调用 Wait() 方法时，它会释放已经持有的锁，并阻塞在条件变量上，直到另一个 Goroutine 调用 Signal() 或 Broadcast() 方法，并释放锁，唤醒了它。被唤醒的 Goroutine 会重新尝试获得锁，然后继续执行。

下面是一个使用 sync.Cond 和 Wait() 方法的示例：

Go 复制代码

package main
import (
    "fmt"
    "sync"
    "time"
)
func main() {
    var mutex sync.Mutex
    cond := sync.NewCond(&mutex)
    ready := false
    go func() {
        time.Sleep(time.Second * 1)
        mutex.Lock()
        ready = true
        cond.Signal()
        mutex.Unlock()
    }()
    mutex.Lock()
    for !ready {
        cond.Wait()
    }
    mutex.Unlock()
    fmt.Println("Goroutine is ready")
}

在这个例子中，我们首先创建了一个 sync.Mutex 实例和一个与之关联的 sync.Cond 实例。我们在一个 Goroutine 中等待 1 秒钟，然后发送一个 Signal() 信号来唤醒等待条件变量的 Goroutine。在主 Goroutine 中，我们首先获取了锁，然后开始等待条件变量。在等待过程中，Goroutine 会释放锁并阻塞在条件变量上，直到另一个 Goroutine 发送了 Signal() 信号并唤醒了它。被唤醒的 Goroutine 会重新尝试获取锁，并在获取到锁后输出一条消息。

需要注意的是，调用 Wait() 方法之前必须先获取锁，否则会出现死锁等问题。另外，在使用 Wait() 方法时，要确保有其他 Goroutine 会发送 Signal() 或 Broadcast() 信号，否则可能会导致 Goroutine 永久阻塞。

14. WaitGroup 用法

在 Go 语言中，sync.WaitGroup 类型提供了一种方便的方式来等待多个 Goroutine 完成它们的任务。WaitGroup 可以被用来跟踪一组 Goroutine，等待它们完成任务并汇总结果。下面是 WaitGroup 的基本用法示例：

Go 复制代码

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Printf("Goroutine %d\n", i)
            wg.Done()
        }(i)
    }
    wg.Wait()
    fmt.Println("All Goroutines are done")
}

在这个示例中，我们首先创建了一个 sync.WaitGroup 实例。然后，在一个 for 循环中创建了 5 个 Goroutine，并调用 wg.Add(1) 方法将计数器加 1，表示有一个 Goroutine 需要等待。在每个 Goroutine 中，我们输出了一条消息，表示该 Goroutine 正在执行任务，并调用 wg.Done() 方法将计数器减 1，表示该 Goroutine 已经完成任务。最后，我们调用 wg.Wait() 方法等待所有 Goroutine 完成任务，然后输出一条消息表示所有 Goroutine 都已完成。

需要注意的是，调用 Add() 方法之后必须调用 Done() 方法，否则会出现死锁等问题。另外，在等待所有 Goroutine 完成任务时，要确保所有 Goroutine 都已经调用了 Done() 方法，否则可能会导致程序永久阻塞。

WaitGroup 还提供了一个 WaitGroup.Add() 方法，可以将计数器增加指定的值，以便一次性添加多个需要等待的 Goroutine。另外，WaitGroup 还支持嵌套使用，即在一个 Goroutine 中使用 WaitGroup 等待一组 Goroutine 完成任务，并在另一个 WaitGroup 中使用这个 Goroutine 作为一项任务等待其他 Goroutine 完成任务。

15. WaitGroup 实现原理

在 Go 语言中，sync.WaitGroup 的实现原理非常简单，它基本上是通过一个计数器来实现的。当我们调用 WaitGroup.Add(n) 方法时，它会将计数器的值增加 n。当我们调用 WaitGroup.Done() 方法时，它会将计数器的值减 1。而当我们调用 WaitGroup.Wait() 方法时，它会阻塞等待，直到计数器的值为 0。

下面是 sync.WaitGroup 的简化版实现，用来更好地理解它的工作原理：

Go 复制代码

type WaitGroup struct {
    counter int32
    cond    *sync.Cond
}
func NewWaitGroup() *WaitGroup {
    return &WaitGroup{
        counter: 0,
        cond:    sync.NewCond(&sync.Mutex{}),
    }
}
func (wg *WaitGroup) Add(delta int) {
    atomic.AddInt32(&wg.counter, int32(delta))
}
func (wg *WaitGroup) Done() {
    atomic.AddInt32(&wg.counter, -1)
    if wg.counter == 0 {
        wg.cond.Broadcast()
    }
}
func (wg *WaitGroup) Wait() {
    wg.cond.L.Lock()
    for wg.counter > 0 {
        wg.cond.Wait()
    }
    wg.cond.L.Unlock()
}

在这个简化版实现中，我们首先创建了一个 WaitGroup 类型，并将计数器初始化为 0。然后，我们使用 sync.Cond 类型来实现等待和通知机制，以便在调用 Wait() 方法时可以阻塞等待。

在 Add() 方法中，我们使用原子操作将计数器的值增加指定的值。在 Done() 方法中，我们使用原子操作将计数器的值减 1，并检查计数器是否为 0。如果计数器为 0，说明所有 Goroutine 都已经完成任务，我们就可以使用 sync.Cond.Broadcast() 方法通知所有正在等待的 Goroutine 继续执行。

在 Wait() 方法中，我们首先获取互斥锁，然后在一个循环中等待计数器的值为 0。在循环中，我们使用 sync.Cond.Wait() 方法释放互斥锁，并等待条件变量上的通知。当计数器的值为 0 时，说明所有 Goroutine 都已经完成任务，我们就可以退出循环，并释放互斥锁。

需要注意的是，这个简化版实现并没有考虑到 WaitGroup 的嵌套使用情况，并且也没有处理 WaitGroup 计数器被减为负数的情况。真正的 sync.WaitGroup 实现要比这个简化版实现复杂得多，但是基本的实现原理是一样的。