Question

我正在尝试使用go lang作为示例任务来实现一个多线程爬虫来学习该语言。

它应该扫描页面，关注链接并将它们保存为数据库。

为避免重复，我正在尝试使用地图保存我已保存的所有网址。

同步版本工作正常，但是当我尝试使用goroutines时遇到麻烦。

我正在尝试使用互斥锁作为地图的同步对象，并使用通道作为协调goroutines的方法。但显然我对它们并不清楚。

问题是我有很多重复的条目，所以我的地图存储/检查无法正常工作。

这是我的代码：

package main

import (
    "fmt"
    "net/http"
    "golang.org/x/net/html"
    "strings"
    "database/sql"
    _ "github.com/ziutek/mymysql/godrv"
    "io/ioutil"
    "runtime/debug"
    "sync"
)

const maxDepth = 2;

var workers = make(chan bool)

type Pages struct {
    mu sync.Mutex
    pagesMap map[string]bool
}

func main() {
    var pagesMutex Pages
    fmt.Println("Start")
    const database = "gotest"
    const user = "root"
    const password = "123"

    //open connection to DB
    con, err := sql.Open("mymysql", database + "/" + user + "/" + password)
    if err != nil { /* error handling */
        fmt.Printf("%s", err)
        debug.PrintStack()
    }

    fmt.Println("call 1st save site")
    pagesMutex.pagesMap = make(map[string]bool)
    go pagesMutex.saveSite(con, "http://golang.org/", 0)

    fmt.Println("saving true to channel")
    workers <- true

    fmt.Println("finishing in main")
    defer con.Close()
}


func (p *Pages) saveSite(con *sql.DB, url string, depth int) {
    fmt.Println("Save ", url, depth)
    fmt.Println("trying to lock")
    p.mu.Lock()
    fmt.Println("locked on mutex")
    pageDownloaded := p.pagesMap[url] == true
    if pageDownloaded {
        p.mu.Unlock()
        return
    } else {
        p.pagesMap[url] = true
    }
    p.mu.Unlock()

    response, err := http.Get(url)
    if err != nil {
        fmt.Printf("%s", err)
        debug.PrintStack()
    } else {
        defer response.Body.Close()

        contents, err := ioutil.ReadAll(response.Body)
        if err != nil {
            if err != nil {
                fmt.Printf("%s", err)
                debug.PrintStack()
            }
        }

        _, err = con.Exec("insert into pages (url) values (?)", string(url))
        if err != nil {
            fmt.Printf("%s", err)
            debug.PrintStack()
        }
        z := html.NewTokenizer(strings.NewReader((string(contents))))

        for {
            tokenType := z.Next()
            if tokenType == html.ErrorToken {
                return
            }

            token := z.Token()
            switch tokenType {
            case html.StartTagToken: // <tag>

                tagName := token.Data
                if strings.Compare(string(tagName), "a") == 0 {
                    for _, attr := range token.Attr {
                        if strings.Compare(attr.Key, "href") == 0 {
                            if depth < maxDepth  {
                                urlNew := attr.Val
                                if !strings.HasPrefix(urlNew, "http")  {
                                    if strings.HasPrefix(urlNew, "/")  {
                                        urlNew = urlNew[1:]
                                    }
                                    urlNew = url + urlNew
                                }
                                //urlNew = path.Clean(urlNew)
                                go  p.saveSite(con, urlNew, depth + 1)

                            }
                        }
                    }

                }
            case html.TextToken: // text between start and end tag
            case html.EndTagToken: // </tag>
            case html.SelfClosingTagToken: // <tag/>

            }

        }

    }
    val := <-workers
    fmt.Println("finished Save Site", val)
}

有人可以向我解释如何正确地做到这一点吗？

Answer 1

嗯，你有两个选择，为了一个简单的实现，我建议将地图上的操作分成一个单独的结构。

// Index is a shared page index
type Index struct {
    access sync.Mutex
    pages map[string]bool
}

// Mark reports that a site have been visited
func (i Index) Mark(name string) {
    i.access.Lock()
    i.pages[name] = true
    i.access.Unlock()
}

// Visited returns true if a site have been visited
func (i Index) Visited(name string) bool {
    i.access.Lock()
    defer i.access.Unlock()

    return i.pages[name]
}

然后，添加另一个结构：

// Crawler is a web spider :D
type Crawler struct {
    index Index
    /* ... other important stuff like visited sites ... */
}

// Crawl looks for content
func (c *Crawler) Crawl(site string) {
    // Implement your logic here 
    // For example: 
    if !c.index.Visited(site) {
        c.index.Mark(site) // When marked
    }
}

通过这种方式，您可以保持良好和清晰，可能需要更多代码，但绝对更具可读性。您需要像这样实例化爬虫：

sameIndex := Index{pages: make(map[string]bool)}
asManyAsYouWant := Crawler{sameIndex, 0} // They will share sameIndex

如果您想进一步使用高级解决方案，那么我建议使用Producer / Consumer架构。

多个goroutine访问/修改列表/映射

1 个答案: