go - 带 channel 的 WaitGroup

Question

我一直在玩this并想出了:

type Function struct{
    Function func(*TaskGroup, []interface{})
    Args []interface{}
}

type TaskGroup struct{
    Group sync.WaitGroup
    Functions []Function
}

func (x *TaskGroup) Start() {
    for _, Function := range x.Functions{
        x.Group.Add(1)
        go Function.Function(x, Function.Args)
    }
    x.Group.Wait()
}

为了更轻松地使用多个功能，我必须等待。

以下测试将起作用，但我不明白为什么:

func auxC(x *TaskGroup, args []interface{}){
    defer x.Group.Done()
    messageOut := args[0].(chan string)
    messageOut <- "TestC"
}
func auxD(x *TaskGroup, args []interface{}){
    defer x.Group.Done()
    messageOut := args[0].(chan string)
    messageOut <- "TestD"
}

func TestTaskGroupBaseB(t *testing.T) {
    messageC := make(chan string, 1)
    messageD := make(chan string, 1)

    tg := TaskGroup{
        Functions: []Function{
            {auxC, []interface{}{messageC}},
            {auxD, []interface{}{messageD}},
        },
    }
    tg.Start()

    fmt.Println(<- messageC)
    fmt.Println(<- messageD)

    time.Sleep(100 * time.Millisecond)
}

我首先尝试使用这样的无缓冲 channel :

messageC := make(chan string)
messageD := make(chan string)

但它不起作用，它只会永远卡住而没有做任何事情， 所以我有几个问题:

为什么大小为 1 的缓冲 channel 可以工作，而未缓冲的 channel 不能？

默认大小1不是无缓冲的吗？

重构代码，见注释:

主要/测试:

func auxC(args []interface{}){
    messageOut := args[0].(chan string)
    messageOut <- "TestC"
}
func auxD(args []interface{}){
    messageOut := args[0].(chan string)
    messageOut <- "TestD"
}

func TestTaskGroupBaseB(t *testing.T) {
    messageC := make(chan string,1)
    messageD := make(chan string,1)

    tg := TaskGroup{
        Functions: []Function{
            {auxC, []interface{}{messageC}},
            {auxD, []interface{}{messageD}},
        },
    }
    tg.Wait()

    fmt.Println(<- messageC)
    fmt.Println(<- messageD)

    time.Sleep(100 * time.Millisecond)
}

任务组:

type Function struct{
    Function func([]interface{})
    Args []interface{}
}

type TaskGroup struct{
    Group sync.WaitGroup
    Functions []Function
}

func (x *TaskGroup) Wait() {
    for _, function := range x.Functions{
        x.Group.Add(1)
        go func(x *TaskGroup, f Function){
            defer x.Group.Done()
            f.Function(f.Args)
        }(x, function)
    }
    x.Group.Wait()
}

Answer 1

使用缓冲区大小为 1 的 channel ，首先写入缓冲区数据，然后 goroutines 结束，您可以在主 goroutine 中读取缓冲数据。

当 channel 大小为零时，对 channel 的写入会阻塞，直到另一个 goroutine 从中读取。所以你的两个 goroutine 都在等待写入 channel 。如果在 channel 读取 main 之后移动 Wait() 调用，它应该可以工作。