递归的Goroutines，告诉Go停止从频道阅读的最简洁的方法是什么？
递归的Goroutines，告诉Go停止从频道阅读的最简洁的方法是什么？
提问于 2014-11-24 10:55:04
我想知道解决这个问题的惯用方法(目前这会引发死锁错误)，递归分支的次数未知，所以我不能简单地关闭通道。
_
我传递了一个指向一个数字的指针，并对其进行了递增，从而使它正常工作，我还研究了使用Sync等待组的问题。我没有感觉到(也许我错了)，我想出了一个优雅的解决方案。我见过的围棋例子往往简单、聪明、简洁。
这是Go巡回赛的最后一次练习，https://tour.golang.org/#73
你知道“围棋程序员”会如何处理这个问题吗？任何帮助都将不胜感激。我正努力从一开始就好好学习。
回答 3
Stack Overflow用户
回答已采纳
发布于 2014-11-24 15:07:45
不需要使用sync.WaitGroup，您可以将结果扩展到解析的url上，并包含找到的新url数量。然后，在主循环中，只要有需要收集的内容，就会继续读取结果。
在您的例子中，找到的urls数量将是生成的go例程数，但不一定需要。我个人会产生多少固定数量的获取例程，这样您就不会打开太多的HTTP请求(或者至少您可以控制它)。那么，主循环不会改变，因为它并不关心如何执行抓取。这里最重要的事实是，您需要为每个url发送一个结果或错误--我已经在这里修改了代码，所以当深度已经为1时，它不会生成新的例程。
此解决方案的一个副作用是，您可以轻松地在主循环中打印进度。
下面是操场上的例子：
http://play.golang.org/p/BRlUc6bojf
package main
import (
"fmt"
)
type Fetcher interface {
// Fetch returns the body of URL and
// a slice of URLs found on that page.
Fetch(url string) (body string, urls []string, err error)
}
type Res struct {
url string
body string
found int // Number of new urls found
}
// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(url string, depth int, fetcher Fetcher, ch chan Res, errs chan error, visited map[string]bool) {
body, urls, err := fetcher.Fetch(url)
visited[url] = true
if err != nil {
errs <- err
return
}
newUrls := 0
if depth > 1 {
for _, u := range urls {
if !visited[u] {
newUrls++
go Crawl(u, depth-1, fetcher, ch, errs, visited)
}
}
}
// Send the result along with number of urls to be fetched
ch <- Res{url, body, newUrls}
return
}
func main() {
ch := make(chan Res)
errs := make(chan error)
visited := map[string]bool{}
go Crawl("http://golang.org/", 4, fetcher, ch, errs, visited)
tocollect := 1
for n := 0; n < tocollect; n++ {
select {
case s := <-ch:
fmt.Printf("found: %s %q\n", s.url, s.body)
tocollect += s.found
case e := <-errs:
fmt.Println(e)
}
}
}
// fakeFetcher is Fetcher that returns canned results.
type fakeFetcher map[string]*fakeResult
type fakeResult struct {
body string
urls []string
}
func (f fakeFetcher) Fetch(url string) (string, []string, error) {
if res, ok := f[url]; ok {
return res.body, res.urls, nil
}
return "", nil, fmt.Errorf("not found: %s", url)
}
// fetcher is a populated fakeFetcher.
var fetcher = fakeFetcher{
"http://golang.org/": &fakeResult{
"The Go Programming Language",
[]string{
"http://golang.org/pkg/",
"http://golang.org/cmd/",
},
},
"http://golang.org/pkg/": &fakeResult{
"Packages",
[]string{
"http://golang.org/",
"http://golang.org/cmd/",
"http://golang.org/pkg/fmt/",
"http://golang.org/pkg/os/",
},
},
"http://golang.org/pkg/fmt/": &fakeResult{
"Package fmt",
[]string{
"http://golang.org/",
"http://golang.org/pkg/",
},
},
"http://golang.org/pkg/os/": &fakeResult{
"Package os",
[]string{
"http://golang.org/",
"http://golang.org/pkg/",
},
},
}是的，请遵循@jimt建议并确保对map线程的访问安全。
Stack Overflow用户
发布于 2014-11-24 12:23:53
下面是我对这项工作的解释。有很多类似的，但这是我的。我使用sync.WaitGroup和一个自定义的互斥保护地图来存储访问过的URL.主要是因为Go的标准map类型不是线程安全的。我还将数据和错误通道组合成一个单一的结构，其中有一种读取所述通道的方法。主要是为了分离关注点和(可以说)保持事物的清洁。
示例在操场上
package main
import (
"fmt"
"sync"
)
type Fetcher interface {
// Fetch returns the body of URL and
// a slice of URLs found on that page.
Fetch(url string) (body string, urls []string, err error)
}
// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(wg *sync.WaitGroup, url string, depth int, fetcher Fetcher, cache *UrlCache, results *Results) {
defer wg.Done()
if depth <= 0 || !cache.AtomicSet(url) {
return
}
body, urls, err := fetcher.Fetch(url)
if err != nil {
results.Error <- err
return
}
results.Data <- [2]string{url, body}
for _, url := range urls {
wg.Add(1)
go Crawl(wg, url, depth-1, fetcher, cache, results)
}
}
func main() {
var wg sync.WaitGroup
cache := NewUrlCache()
results := NewResults()
defer results.Close()
wg.Add(1)
go Crawl(&wg, "http://golang.org/", 4, fetcher, cache, results)
go results.Read()
wg.Wait()
}
// Results defines channels which yield results for a single crawled URL.
type Results struct {
Data chan [2]string // url + body.
Error chan error // Possible fetcher error.
}
func NewResults() *Results {
return &Results{
Data: make(chan [2]string, 1),
Error: make(chan error, 1),
}
}
func (r *Results) Close() error {
close(r.Data)
close(r.Error)
return nil
}
// Read reads crawled results or errors, for as long as the channels are open.
func (r *Results) Read() {
for {
select {
case data := <-r.Data:
fmt.Println(">", data)
case err := <-r.Error:
fmt.Println("e", err)
}
}
}
// UrlCache defines a cache of URL's we've already visited.
type UrlCache struct {
sync.Mutex
data map[string]struct{} // Empty struct occupies 0 bytes, whereas bool takes 1 bytes.
}
func NewUrlCache() *UrlCache { return &UrlCache{data: make(map[string]struct{})} }
// AtomicSet sets the given url in the cache and returns false if it already existed.
//
// All within the same locked context. Modifying a map without synchronisation is not safe
// when done from multiple goroutines. Doing a Exists() check and Set() separately will
// create a race condition, so we must combine both in a single operation.
func (c *UrlCache) AtomicSet(url string) bool {
c.Lock()
_, ok := c.data[url]
c.data[url] = struct{}{}
c.Unlock()
return !ok
}
// fakeFetcher is Fetcher that returns canned results.
type fakeFetcher map[string]*fakeResult
type fakeResult struct {
body string
urls []string
}
func (f fakeFetcher) Fetch(url string) (string, []string, error) {
if res, ok := f[url]; ok {
return res.body, res.urls, nil
}
return "", nil, fmt.Errorf("not found: %s", url)
}
// fetcher is a populated fakeFetcher.
var fetcher = fakeFetcher{
"http://golang.org/": &fakeResult{
"The Go Programming Language",
[]string{
"http://golang.org/pkg/",
"http://golang.org/cmd/",
},
},
"http://golang.org/pkg/": &fakeResult{
"Packages",
[]string{
"http://golang.org/",
"http://golang.org/cmd/",
"http://golang.org/pkg/fmt/",
"http://golang.org/pkg/os/",
},
},
"http://golang.org/pkg/fmt/": &fakeResult{
"Package fmt",
[]string{
"http://golang.org/",
"http://golang.org/pkg/",
},
},
"http://golang.org/pkg/os/": &fakeResult{
"Package os",
[]string{
"http://golang.org/",
"http://golang.org/pkg/",
},
},
}这还没有经过广泛的测试，所以可能有一些优化和修复可以应用，但它至少应该给您一些想法。
Stack Overflow用户
发布于 2019-01-04 10:04:34
这是我如何解决网络爬虫练习的围棋
用于跟踪并行执行中的递归完成，我使用了原子整数计数器来跟踪有多少urls在并行递归中被爬行。在主函数中，我在循环中等待，直到原子计数器减少到零。
为了避免再次抓取相同的，我使用了一个带有Mutex的地图来跟踪爬行的URL。
下面是相同的代码片段。
你可以找到在Github上的整个工作代码
// Safe HashSet Version
type SafeHashSet struct {
sync.Mutex
urls map[string]bool //Primarily we wanted use this as an hashset, so the value of map is not significant to us
}
var (
urlSet SafeHashSet
urlCounter int64
)
// Adds an URL to the Set, returns true if new url was added (if not present already)
func (m *SafeHashSet) add(newUrl string) bool {
m.Lock()
defer m.Unlock()
_, ok := m.urls[newUrl]
if !ok {
m.urls[newUrl] = true
return true
}
return false
}
// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(url string, depth int, fetcher Fetcher) {
// Decrement the atomic url counter, when this crawl function exits
defer atomic.AddInt64(&urlCounter, -1)
if depth <= 0 {
return
}
// Don't Process a url if it is already processed
isNewUrl := urlSet.add(url)
if !isNewUrl {
fmt.Printf("skip: \t%s\n", url)
return
}
body, urls, err := fetcher.Fetch(url)
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("found: \t%s %q\n", url, body)
for _, u := range urls {
atomic.AddInt64(&urlCounter, 1)
// Crawl parallely
go Crawl(u, depth-1, fetcher)
}
return
}
func main() {
urlSet = SafeHashSet{urls: make(map[string]bool)}
atomic.AddInt64(&urlCounter, 1)
go Crawl("https://golang.org/", 4, fetcher)
for atomic.LoadInt64(&urlCounter) > 0 {
time.Sleep(100 * time.Microsecond)
}
fmt.Println("Exiting")
}页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/27103161
复制相关文章
相似问题
腾讯云开发者
