'A Tour of Go'的Crawl例子goroutine没有生效

Question

正如“A Tour of Go”的 Crawl 示例中提到的命中，我修改了 Crawl 函数，只是想知道为什么“go Crawl”无法生成另一个线程，因为只找到一个 url 被打印出来。

我的修改有问题吗？

如下列出我的修改，

// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(url string, depth int, fetcher Fetcher) {
    // TODO: Fetch URLs in parallel.
    // TODO: Don't fetch the same URL twice.
    // This implementation doesn't do either:
    if depth <= 0 {
        fmt.Printf("depth <= 0 return")
        return
    }
    body, urls, err := fetcher.Fetch(url)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("found: %s %q\n", url, body)
    crawled.mux.Lock()
    crawled.c[url]++
    crawled.mux.Unlock()
    for _, u := range urls {
        //crawled.mux.Lock()
        if cnt, ok := crawled.c[u]; ok {
            cnt++
        } else {
            fmt.Println("go ...", u)
            go Crawl(u, depth-1, fetcher)
        }
        //crawled.mux.Unlock()
        //Crawl(u, depth-1, fetcher)
    }
    return
}


type crawledUrl struct {
    c   map[string]int
    mux sync.Mutex
}

var crawled = crawledUrl{c: make(map[string]int)}

Answer 1

在您的程序中，您的 go 例程没有任何同步工具。

所以这段代码的行为是未定义的。 也许 go 主线程很快就会结束。

请记住，主 go 例程永远不会阻塞以等待其他 go 例程终止，除非您明确使用某种 util 来同步 go 例程的执行。

例如 channel 或有用的同步工具。

我帮忙给个版本

type fetchState struct {
    mu      sync.Mutex
    fetched map[string]bool
}

func (f *fetchState) CheckAndMark(url string) bool {
    defer f.mu.Unlock()

    f.mu.Lock()
    if f.fetched[url] {
        return true
    }
    f.fetched[url] = true
    return false
}

func mkFetchState() *fetchState {
    f := &fetchState{}
    f.fetched = make(map[string]bool)
    return f
}

func CrawlConcurrentMutex(url string, fetcher Fetcher, f *fetchState) {
    if f.CheckAndMark(url) {
        return
    }

    body, urls, err := fetcher.Fetch(url)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("found: %s %q\n", url, body)
    var done sync.WaitGroup
    for _, u := range urls {
        done.Add(1)
        go func(u string) {
            defer done.Done()
            CrawlConcurrentMutex(u, fetcher, f)
        }(u) // Without the u argument there is a race
    }
    done.Wait()
    return
}

请注意sync.WaitGroup的使用，引用doc你可以了解整个故事。