我正在尝试为我正在使用 BFS 的给定词抓取相关词，从给定词开始并在 dictionary.com 上搜索每个相关词

我已经在没有并发的情况下尝试过这段代码，它工作得很好，但需要很多时间，因此尝试使用 go routines 但我的代码在第一次迭代后卡住了。第一级 BFS 工作正常，但在第二级它挂起!

package main

import (
    "fmt"
    "github.com/gocolly/colly"
    "sync"
)

var wg sync.WaitGroup


func buildURL(word string) string {
    return "https://www.dictionary.com/browse/" + string(word)
}

func get(url string) []string {
    c := colly.NewCollector()
    c.IgnoreRobotsTxt = true
    var ret []string
    c.OnHTML("a.css-cilpq1.e15p0a5t2", func(e *colly.HTMLElement) {
        ret = append(ret, string(e.Text))
    })
    c.Visit(url)
    c.Wait()

    return ret
}

func threading(c chan []string, word string) {
    defer wg.Done()
    var words []string
    for _, w := range get(buildURL(word)) {
        words = append(words, w)
    }
    c <- words
}

func main() {
    fmt.Println("START")
    word := "jump"
    maxDepth := 2

    //bfs
    var q map[string]int
    nq := map[string]int {
        word: 0,
    }

    vis := make(map[string]bool)
    queue := make(chan []string, 5000)

    for i := 1; i <= maxDepth; i++ {
        fmt.Println(i)
        q, nq = nq, make(map[string]int)
        for word := range q {
            if _, ok := vis[word]; !ok {
                wg.Add(1)
                vis[word] = true
                go threading(queue, word)

                for v := range queue {
                    fmt.Println(v)
                    for _, w := range v {
                        nq[w] = i
                    }
                }
            }
        }
    }
    wg.Wait()
    close(queue)
    fmt.Println("END")
}

输出:

START
1
[plunge dive rise upsurge bounce hurdle fall vault drop advance upturn inflation increment spurt boost plummet skip bound surge take]

永远卡在这里，不打印 counter = 2!

可以在这里查看https://www.dictionary.com/browse/jump对于相关词。

最佳答案

根据 Tour of Go

Sends to a buffered channel block only when the buffer is full. Receives block when the buffer is empty.

因此，在这种情况下，您将创建一个长度为 5000 的缓冲 channel 。

for i := 1; i <= maxDepth; i++ {
    fmt.Println(i)
    q, nq = nq, make(map[string]int)
    for word := range q { // for each word
        if _, ok := vis[word]; !ok { // if not visited visit
            wg.Add(1) // add a worker
            vis[word] = true
            go threading(queue, word) // fetch in concurrent manner
            for v := range queue { // <<< blocks here when queue is empty
                fmt.Println(v)
                for _, w := range v {
                    nq[w] = i
                }
            }
        }
    }
}

如您所见，我在代码中评论道，在第一次迭代后，for 循环将阻塞，直到 channel 为空。在这种情况下，在获取 jump 之后，它会发送数组对应的相似词，但之后因为 for 循环被阻塞，正如 zerkems 解释的那样，你将无法进行下一次迭代(i = 2).您最终可以关闭 channel 以结束 for 循环中的阻塞。但是因为你使用同一个 channel 来覆盖多个 goroutines，如果你从多个 goroutines 关闭它，它会 panic。

为了克服这个问题，我们可以想出一个很好的解决方法。

1. 我们确切地知道我们正在获取多少未访问的项目。
2. 我们现在知道障碍在哪里了

首先，我们需要计算未访问过的词，然后我们可以迭代那么多的时间

    vis := make(map[string]bool)
    queue := make(chan []string, 5000)
    for i := 1; i <= maxDepth; i++ {
        fmt.Println(i)
        q, nq = nq, make(map[string]int)
        unvisited := 0
        for word := range q {
            if _, ok := vis[word]; !ok {
                vis[word] = true
                unvisited++
                wg.Add(1)
                go threading(queue, word)
            }
        }

        wg.Wait() // wait until jobs are done
        for j := 0; j < unvisited; j++ { // << does not block as we know how much
            v := <-queue // we exactly try to get unvisited amount
            fmt.Println(v)
            for _, w := range v {
                nq[w] = i
            }
        }
    }

在这种情况下，我们只是计算获得结果所需的最少迭代次数。此外，您可以看到我已经将 for 循环移到外部并使用原始循环来向 workers 添加单词。它将要求获取所有单词，并在接下来的循环中等待以非阻塞方式完成任务。

后一个循环等待所有工作人员完成。在下一次迭代之后，可以达到工作和 BFS 的下一个级别。

总结

1. 分配工作量
2. 等待结果
3. 不要同时做这两件事

希望这对您有所帮助。

关于go - 尝试使用 go routines 时无法抓取数据，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56693590/