传递 WaitGroup 到函数中会如何影响其行为？

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《传递 WaitGroup 到函数中会如何影响其行为？》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

我有 3 个合并排序实现：

mergesort：简单的排序，无并发；

mergesortsmart：并发性受缓冲通道大小限制。如果缓冲区已满，则调用简单实现；

mergesortsmartbug：与前一个策略相同，但有一个小的“重构”，将 wg 指针传递给函数以减少代码重复。

前两个按预期工作，但第三个返回空切片而不是排序后的输入。我无法理解发生了什么，也找不到答案。

以下是代码的演示链接：https://play.golang.org/p/du1ypbanpvi

package main

import (
    "fmt"
    "math/rand"
    "runtime"
    "sync"
)

type pass struct{}

var semaphore = make(chan pass, runtime.NumCPU())

func main() {
    rand.Seed(10)
    s := make([]int, 16)
    for i := 0; i < 16; i++ {
        s[i] = int(rand.Int31n(1000))
    }

    fmt.Println(s)
    fmt.Println(MergeSort(s))
    fmt.Println(MergeSortSmart(s))
    fmt.Println(MergeSortSmartBug(s))
}

func merge(l, r []int) []int {
    tmp := make([]int, 0, len(l)+len(r))
    for len(l) > 0 || len(r) > 0 {
        if len(l) == 0 {
            return append(tmp, r...)
        }
        if len(r) == 0 {
            return append(tmp, l...)
        }
        if l[0] <= r[0] {
            tmp = append(tmp, l[0])
            l = l[1:]
        } else {
            tmp = append(tmp, r[0])
            r = r[1:]
        }
    }
    return tmp
}

func MergeSort(s []int) []int {
    if len(s) <= 1 {
        return s
    }

    n := len(s) / 2

    l := MergeSort(s[:n])
    r := MergeSort(s[n:])

    return merge(l, r)
}

func MergeSortSmart(s []int) []int {
    if len(s) <= 1 {
        return s
    }

    n := len(s) / 2

    var wg sync.WaitGroup
    wg.Add(2)

    var l, r []int
    select {
    case semaphore <- pass{}:
        go func() {
            l = MergeSortSmart(s[:n])
            <-semaphore
            wg.Done()
        }()
    default:
        l = MergeSort(s[:n])
        wg.Done()
    }

    select {
    case semaphore <- pass{}:
        go func() {
            r = MergeSortSmart(s[n:])
            <-semaphore
            wg.Done()
        }()
    default:
        r = MergeSort(s[n:])
        wg.Done()
    }

    wg.Wait()
    return merge(l, r)
}

func MergeSortSmartBug(s []int) []int {
    if len(s) <= 1 {
        return s
    }

    n := len(s) / 2

    var wg sync.WaitGroup
    wg.Add(2)

    l := mergeSmart(s[:n], &wg)
    r := mergeSmart(s[n:], &wg)

    wg.Wait()
    return merge(l, r)
}

func mergeSmart(s []int, wg *sync.WaitGroup) []int {
    var tmp []int
    select {
    case semaphore <- pass{}:
        go func() {
            tmp = MergeSortSmartBug(s)
            <-semaphore
            wg.Done()
        }()
    default:
        tmp = MergeSort(s)
        wg.Done()
    }
    return tmp
}

为什么bug版本返回空切片？如何在不进行两个选择的情况下重构智能版本？

抱歉，我无法在较小的示例中重现此行为。

正确答案

问题不在于 waitgroup 本身。这与你的并发处理有关。您的 mergesmart 函数启动 go 例程并返回 tmp 变量，而无需等待 go 例程完成。 您可能想尝试更像这样的模式：

leftchan := make(chan []int)
rightchan := make(chan []int)
go mergeSmart(s[:n], leftchan)
go mergeSmart(s[n:], rightchan)
l := <-leftchan
r := <-rightchan

如果顺序不重要，您也可以使用单个渠道。

今天关于《传递 WaitGroup 到函数中会如何影响其行为？》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！