我需要搜索一个巨大的 slice maps[string]string。我的想法是，这是 go 的 channel 和 go 例程的好机会。

计划是将 slice 分成几部分并并行发送搜索。 但令我感到震惊的是，我的并行版本在搜索整个 slice 时超时了。

我不确定我做错了什么。下面是我用来测试这个概念的代码。真正的代码会涉及更多的复杂性

//Search for a giving term
//This function gets the data passed which will need to be search
//and the search term and it will return the matched maps
// the data is pretty simply the map contains { key: andSomeText }
func Search(data []map[string]string, term string) []map[string]string {

    set := []map[string]string{}

    for _, v := range data {
        if v["key"] == term {

            set = append(set, v)
        }

    }
    return set

}

因此，对于给定 SearchTerm 的 map slice 搜索，这非常有效。

现在我想如果我的 slice 有 20K 个条目，我想并行搜索

// All searches all records concurrently
// Has the same function signature as the the search function
// but the main task is to fan out the slice in 5 parts and search
// in parallel
func All(data []map[string]string, term string) []map[string]string {
    countOfSlices := 5

    part := len(data) / countOfSlices

    fmt.Printf("Size of the data:%v\n", len(data))
    fmt.Printf("Fragemnt Size:%v\n", part)

    timeout := time.After(60000 * time.Millisecond)

    c := make(chan []map[string]string)

    for i := 0; i < countOfSlices; i++ {
        // Fragments of the array passed on to the search method
        go func() { c <- Search(data[(part*i):(part*(i+1))], term) }()

    }

    result := []map[string]string{}

    for i := 0; i < part-1; i++ {
        select {
        case records := <-c:
            result = append(result, records...)
        case <-timeout:
            fmt.Println("timed out!")
            return result
        }
    }
    return result
}

这是我的测试:

我有一个函数可以生成我的测试数据和 2 个测试。

func GenerateTestData(search string) ([]map[string]string, int) {
    rand.Seed(time.Now().UTC().UnixNano())
    strin := []string{"String One", "This", "String Two", "String Three", "String Four", "String Five"}
    var matchCount int
    numOfRecords := 20000
    set := []map[string]string{}
    for i := 0; i < numOfRecords; i++ {
        p := rand.Intn(len(strin))
        s := strin[p]
        if s == search {
            matchCount++
        }
        set = append(set, map[string]string{"key": s})
    }
    return set, matchCount
}

两个测试:第一个只是遍历 slice ，第二个是并行搜索

func TestSearchItem(t *testing.T) {

    tests := []struct {
        InSearchTerm string
        Fn           func(data []map[string]string, term string) []map[string]string
    }{
        {
            InSearchTerm: "This",
            Fn:           Search,
        },
        {InSearchTerm: "This",
            Fn: All,
        },
    }

    for i, test := range tests {

        startTime := time.Now()
        data, expectedMatchCount := GenerateTestData(test.InSearchTerm)
        result := test.Fn(data, test.InSearchTerm)

        fmt.Printf("Test: [%v]:\nTime: %v \n\n", i+1, time.Since(startTime))
        assert.Equal(t, len(result), expectedMatchCount, "expected: %v to be: %v", len(result), expectedMatchCount)

    }
}

如果有人能解释为什么我的并行代码这么慢，那就太好了？代码有什么问题，我在这里遗漏了什么，以及推荐的方法是在内存 50K+ 中搜索巨大的 slice 。

最佳答案

这看起来只是一个简单的错字。问题是您将原始的大 slice 分成 5 block (countOfSlices)，然后正确启动 5 个 goroutine 来搜索每个部分:

for i := 0; i < countOfSlices; i++ {
    // Fragments of the array passed on to the search method
    go func() { c <- Search(data[(part*i):(part*(i+1))], term) }()

}

这意味着您应该期待 5 个结果，但您没有。您期望 4000-1 结果:

for i := 0; i < part-1; i++ {
    select {
    case records := <-c:
        result = append(result, records...)
    case <-timeout:
        fmt.Println("timed out!")
        return result
    }
}

显然，如果您只启动了 5 个 goroutine，每个 goroutine 都提供 1 个结果，那么您只能期望有 5 个。由于您的循环等待了更多时间(永远不会到来)，因此它会按预期超时。

把条件改成这样:

for i := 0; i < countOfSlices; i++ {
    // ...
}

关于go - 如何同时搜索一大片 maps[string]string，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41783180/