我一直在研究这个并想出了：
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)
}
我首先尝试使用像这样的无缓冲通道：
messageC := make(chan string)
messageD := make(chan string)
但它不起作用，它只是永远卡住而不做任何事情，所以我有几个问题：
为什么大小为 1 的缓冲通道可以工作，而无缓冲通道则不能？
默认大小不是无缓冲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
Cats萌萌
相关分类