从并发到并行解析Go语言中的sync.WaitGroup（go并发编程百度网盘）真没想到

🌐 经济型：买域名、轻量云服务器、用途：游戏网站等《腾讯云》特点：特价机便宜适合初学者用点我优惠购买

🚀 拓展型：买域名、轻量云服务器、用途：游戏网站等《阿里云》特点：中档服务器便宜域名备案事多点我优惠购买

🛡️ 稳定型：买域名、轻量云服务器、用途：游戏网站等《西部数码》特点：比上两家略贵但是稳定性超好事也少点我优惠购买

目录1. 理解并发与并行2. sync.WaitGroup 的作用和用法2.1 sync.WaitGroup 结构体的定义2.2 sync.WaitGroup 的方法2.3 使用示例3. sync.WaitGroup 的工作原理3.1 原子操作3.2 WaitGroup 的实现原理4. 高级技巧与注意事项4.1 使用带缓冲的通道4.2 错误处理和超时机制5. 总结

在并发编程中，协调多个 goroutine 的执行是一个常见的需求。Go 语言提供了许多工具和机制来实现并发编程，其中之一就是 sync.WaitGroup。本文将深入讨论 sync.WaitGroup，探索其工作原理和在实际应用中的使用方法。

在开始介绍 sync.WaitGroup 之前，我们需要先了解并发和并行的概念。并发是指多个任务交替进行，通过时间片轮转或者调度算法进行切换，从而给用户一种同时执行的感觉。而并行是指多个任务同时进行，利用多核处理器或者分布式系统的计算能力，实现真正的同时执行。

sync.WaitGroup 是 Go 语言标准库中的一个结构体，用于等待一组 goroutine 完成执行。它的主要作用是等待所有的 goroutine 完成后再继续执行下一步操作，以避免主程序过早退出。

sync.WaitGroup 的定义如下：

type WaitGroup struct {
noCopy noCopy
?
// 64-bit value: high 32 bits are counter, low 32 bits are waiter count.
// Wait 调用时，counter 自增；Done 调用时，counter 自减；WaitGroup 的值可以使用 Add 和 Done 方法增减。
// 当 counter 为零时，所有等待的 goroutine 都会被唤醒。
// 因为 counter 是 int64 类型，所以 WaitGroup 最多支持 2^32 个 goroutine。
// 如果 counter 为负数，会导致 panic。
state1 [3]uint32
}

sync.WaitGroup 结构体中的 state1 字段包含了一个 counter 计数器，用于记录等待的 goroutine 数量。

sync.WaitGroup 提供了以下几个方法：

2.2.1 Add 方法

Add 方法用于向 WaitGroup 中添加指定数量的等待的 goroutine。它的定义如下：

func (wg *WaitGroup) Add(delta int)

其中，delta 表示要添加的等待的 goroutine 的数量。Add 方法会将 delta 值加到 counter 上。

2.2.2 Done 方法

Done 方法用于标记一个等待的 goroutine 已经完成。它的定义如下：

func (wg *WaitGroup) Done()

Done 方法会将 counter 减 1。

2.2.3 Wait 方法

Wait 方法用于阻塞当前的 goroutine，直到所有的等待的 goroutine 完成。它的定义如下：

func (wg *WaitGroup) Wait()

Wait 方法会检查 counter 的值，如果不为 0，则当前的 goroutine 会被阻塞。当 counter 的值为 0 时，阻塞解除，当前的 goroutine 可以继续执行。

下面是一个示例代码，演示了如何使用 sync.WaitGroup：

package main
?
import (
“fmt”
“sync”
“time”
)
?
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf(“Worker %d starting\n”, id)
time.Sleep(time.Second)
fmt.Printf(“Worker %d done\n”, id)
}
?
func main() {
var wg sync.WaitGroup
?
for i :=1; i <=5; i++ {
wg.Add(1)
go worker(i, &wg)
}
?
wg.Wait()
fmt.Println(“All workers completed”)
}

在上述示例中，我们创建了 5 个 worker goroutine，并使用 wg.Add(1) 将每个 goroutine 添加到 WaitGroup 中。然后，通过调用 wg.Wait() 阻塞主 goroutine，直到所有的 worker goroutine 完成执行。最后，打印出 “All workers completed” 表示所有的 worker goroutine 已经完成。

了解 sync.WaitGroup 的工作原理对于正确使用它至关重要。在深入理解 sync.WaitGroup 的工作原理之前，我们需要了解一些关于并发编程和原子操作的基本知识。

在并发编程中，原子操作是指不能被中断的操作，要么完全执行，要么完全不执行。在 Go 语言中，原子操作可以使用 sync/atomic 包提供的函数来实现。

sync.WaitGroup 的实现依赖于原子操作。sync.WaitGroup 的 counter 字段是一个 64 位的无符号整数，其中高 32 位用于计数，低 32 位用于记录等待的 goroutine 数量。

当调用 Add 方法时，它会使用原子操作将 delta 值加到 counter 上。当调用 Done 方法时，它会使用原子操作将 counter 减 1。而 Wait 方法会通过循环检查 counter 的值，如果不为 0 则阻塞。

在 Wait 方法内部，通过调用 runtime.gopark 函数将当前的 goroutine 休眠，直到 counter 的值为 0。当 counter 的值为 0 时，调用 runtime.goready 函数唤醒被休眠的 goroutine，使其继续执行。

除了基本的使用方法之外，还有一些高级技巧和注意事项需要了解。

在某些情况下，我们可能需要限制并发执行的 goroutine 数量。可以通过使用带缓冲的通道结合 sync.WaitGroup 来实现。

package main
?
import (
“fmt”
“sync”
“time”
)
?
func worker(id int, wg *sync.WaitGroup, ch chan struct{}) {
defer wg.Done()
?
// 在执行任务前，从通道获取一个令牌
<-ch
?
fmt.Printf(“Worker %d starting\n”, id)
time.Sleep(time.Second)
fmt.Printf(“Worker %d done\n”, id)
?
// 任务完成后，将令牌放回通道
ch <- struct{}{}
}
?
func main() {
const numWorkers=3
var wg sync.WaitGroup
ch :=make(chan struct{}, numWorkers)
?
for i :=1; i <=5; i++ {
wg.Add(1)
go worker(i, &wg, ch)
}
?
for i :=0; i < numWorkers; i++ {
ch <- struct{}{} // 初始化通道，放入令牌
}
?
wg.Wait()
fmt.Println(“All workers completed”)
}

在上述示例中，我们创建了一个带缓冲的通道 ch，其容量为 numWorkers，即最大并发执行的 goroutine 数量。在每个 worker goroutine 的开头，它会从通道 ch 中获取一个令牌，这表示该 goroutine 可以执行任务。在任务完成后，将令牌放回通道。通过控制令牌的数量，我们可以限制并发执行的 goroutine 数量。

在实际应用中，我们通常需要添加错误处理和超时机制来提高程序的可靠性。可以使用 select 语句和 time.After 函数来实现这些机制。

package main
?
import (
“fmt”
“sync”
“time”
)
?
func worker(id int, wg *sync.WaitGroup, errCh chan error) {
defer wg.Done()
?
// 模拟任务执行
time.Sleep(time.Second * 2)
?
// 模拟任务出错
if id==3 {
errCh <- fmt.Errorf(“error occurred in worker %d”, id)
return
}
?
fmt.Printf(“Worker %d done\n”, id)
}
?
func main() {
var wg sync.WaitGroup
errCh :=make(chan error)
?
for i :=1; i <=5; i++ {
wg.Add(1)
go worker(i, &wg, errCh)
}
?
go func() {
wg.Wait()
close(errCh)
}()
?
select {
case err :=<-errCh:
fmt.Printf(“Error: %v\n”, err)
case <-time.After(time.Second * 3):
fmt.Println(“Timeout occurred”)
}
?
fmt.Println(“All workers completed”)
}

在上述示例中，我们创建了一个 errCh 通道，用于接收可能发生的错误。在每个 worker goroutine 的开头，如果任务出现错误，会将错误信息发送到 errCh 通道。在主 goroutine 中，使用 select 语句监听 errCh 通道和 time.After 通道。如果从 errCh 通道接收到错误，会输出错误信息；如果在 3 秒内没有从errCh通道接收到错误，会触发超时。

通过深入理解和正确使用 sync.WaitGroup，我们可以实现优雅且高效的并发编程。在本文中，我们详细介绍了 sync.WaitGroup 的作用和用法，包括 Add、Done 和 Wait 方法的使用。我们还讨论了 sync.WaitGroup 的内部工作原理，它依赖于原子操作来实现并发的同步和等待。

通过合理地使用 sync.WaitGroup，我们可以避免竞态条件和资源泄漏，提高程序的可维护性和可靠性。它是实现并发任务协调的重要工具之一。

希望本文能够对大家深入理解 Go 中的 sync.WaitGroup 提供帮助，并能在实际应用中获得更好的效果。通过掌握并正确使用 sync.WaitGroup，可以更好地控制并发任务的执行，充分发挥 Go 语言在并发编程方面的优势。

以上就是从并发到并行解析Go语言中的sync.WaitGroup的详细内容，更多关于Go语言sync.WaitGroup的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:GoLang的sync.WaitGroup与sync.Once简单使用讲解go?sync?Waitgroup数据结构实现基本操作详解Go sync WaitGroup使用深入理解Go语言同步等待组sync.WaitGroup结构体对象方法详解Go并发:使用sync.WaitGroup实现协程同步方式在golang中使用Sync.WaitGroup解决等待的问题Golang中的sync包的WaitGroup操作Golang中的sync.WaitGroup用法实例