使用golangwaitgroup实现并发任务

一、什么是golangwaitgroup

golangwaitgroup是Go语言中的一个并发原语，它能够有效地控制执行goroutine的顺序。它类似于一个计数器，可以在启动一组goroutine之前，将计数器设置为指定的值，然后将计数器逐个减1，直到计数器值为0，它会等待所有并发任务完成之后再进行下一步的操作。

为了使用golangwaitgroup，我们需要先导入“sync”包，然后实例化一个wait group，通过wait group的方法（Add、Done、Wait）来控制并发任务的执行顺序。

二、如何使用golangwaitgroup编写并发任务

下面是一个简单的例子，演示如何使用golangwaitgroup实现几个并发任务：

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    // 模拟耗时操作
    for i := 0; i < 100000000; i++ {

    }
    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 done!")
}

在这个例子中，我们定义了一个worker函数来代表具体的并发任务，worker函数接受一个id值和一个wait group作为参数，打印一些信息然后模拟一个耗时的操作。

在main函数中，我们实例化了一个wait group，然后启动了5个goroutine，每一个goroutine都调用worker函数，当一个goroutine结束时，调用wait group的Done()方法来减少计数器的值。

调用wait group的Wait()方法会阻塞当前goroutine之后的代码，直到所有的goroutine都完成并且计数器的值变为0。

三、如何解决golangwaitgroup的常见问题

使用golangwaitgroup如果没有正确处理可能会导致几个常见的问题，下面是一些通用的方法来解决这些问题。

并发调用时，如何避免重复调用

在并发调用时，我们需要确保多个goroutine不会同时调用同一个函数，否则可能会导致不可预期的结果。一个常见的解决方法就是通过channel来控制goroutine的并发数量，代码如下：

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        fmt.Printf("worker %d starting job %d\n", id, j)
        // 模拟耗时操作
        for i := 0; i < 100000000; i++ {

        }
        fmt.Printf("worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    var wg sync.WaitGroup

    numJobs := 10
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    wg.Wait()
    close(results)

    for r := range results {
        fmt.Println(r)
    }
}

在这个例子中，我们创建了两个channel，一个用于存放任务，另一个用于存放结果。每一个goroutine都从jobs channel中读取任务，然后执行任务。如果jobs channel被关闭，那么goroutine就会退出。

使用channel来控制goroutine的并发数量也可以避免在调用Wait()方法时出现死锁的情况，因为我们已经在指定的goroutine数量处理完后关闭了jobs channel。

当任务出现错误时，如何正确定义wait group的计数

在工作过程中，有可能某些任务不会完成，比如说因为网络问题而出现连接失败等。在这种情况下，如果直接调用Done()方法，会导致计数器的值错误地递减，从而导致程序无法正确退出。

一个常见的解决方法就是在defer语句中捕获错误，然后在错误处理代码中将计数器的值增加回来，以保证计数器在出现错误后仍能够正确处理。

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("Worker failed:", err)
            wg.Add(1)
        }
        wg.Done()
    }()
    fmt.Printf("Worker %d starting\n", id)
    // 模拟出现错误的情况
    if id == 3 {
        panic("worker failed")
    }
    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 done!")
}

在这个例子中，我们在worker函数中模拟了一个出现错误的情况，当第三个goroutine执行的时候，会抛出一个panic异常，然后被main函数的defer语句捕获。

在defer语句中，我们首先检查是否有错误发生，如果有的话，就打印出来，然后调用wait group的Add()方法将计数器的值增加1。

在实际的工作中，我们也可以通过其他的方式来处理错误，比如说使用日志来记录错误信息，然后再根据错误之前的状态来恢复重试。

原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/182060.html