Go语言之旅-练习-Web爬虫

在这个练习中，我们将会使用 Go 的并发特性来并行化一个 Web 爬虫。

提示：你可以用一个 map 来缓存已经获取的 URL，但是要注意 map 本身并不是并发安全的！

package main

import (
    "fmt"
)

type Fetcher interface {
    // Fetch 返回 URL 的 body 内容，并且将在这个页面上找到的 URL 放到一个 slice 中。
    Fetch(url string) (body string, urls []string, err error)
}

// Crawl 使用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。
func Crawl(url string, depth int, fetcher Fetcher) {
    // TODO: 并行的抓取 URL。
    // TODO: 不重复抓取页面。
        // 下面并没有实现上面两种情况：
    if depth <= 0 {
        return
    }
    body, urls, err := fetcher.Fetch(url)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("found: %s %q\n", url, body)
    for _, u := range urls {
        Crawl(u, depth-1, fetcher)
    }
    return
}

func main() {
    Crawl("https://golang.org/", 4, fetcher)
}

// fakeFetcher 是返回若干结果的 Fetcher。
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 是填充后的 fakeFetcher。
var fetcher = fakeFetcher{
    "https://golang.org/": &fakeResult{
        "The Go Programming Language",
        []string{
            "https://golang.org/pkg/",
            "https://golang.org/cmd/",
        },
    },
    "https://golang.org/pkg/": &fakeResult{
        "Packages",
        []string{
            "https://golang.org/",
            "https://golang.org/cmd/",
            "https://golang.org/pkg/fmt/",
            "https://golang.org/pkg/os/",
        },
    },
    "https://golang.org/pkg/fmt/": &fakeResult{
        "Package fmt",
        []string{
            "https://golang.org/",
            "https://golang.org/pkg/",
        },
    },
    "https://golang.org/pkg/os/": &fakeResult{
        "Package os",
        []string{
            "https://golang.org/",
            "https://golang.org/pkg/",
        },
    },
}

这个任务的实现可以借助较为传统的互斥锁来解决。一方面，我们希望使用一个map缓存已经爬取过的url;另一方面，我们需要把Crawl函数并行化。这需要处理多个线程读写map所带来的线程安全问题。

代码实现

package main

import (
    "fmt"
    "sync"
)

type Fetcher interface {
    // Fetch 返回 URL 的 body 内容，并且将在这个页面上找到的 URL 放到一个 slice 中。
    Fetch(url string) (body string, urls []string, err error)
}
type SafeMap struct {
    // mux是一个锁，go确保上锁的代码段在相同时间仅有一个Go程在执行
    m map[string]string
    mux sync.Mutex
}
var urlMap = SafeMap{m:make(map[string]string , 0)}
// 使用一个WaitGroup来阻塞主线程，直到爬取完成
var wg sync.WaitGroup
// Crawl 使用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。
func Crawl(url string, depth int, fetcher Fetcher) {
    // 无论Crawl错误还是正常爬取，我们认为他的任务完成了
    // 使用defer wg.Done()确保我们的Waitgroup减去了1
    defer wg.Done()
    if depth <= 0 {
        return
    }
    body, urls, err := fetcher.Fetch(url)
    // 上锁需要写urlMap的代码段，阻止其他go程读写所带来的读写冲突
    urlMap.mux.Lock()
    // 确保锁最后能够释放，使用defer等效于在两个return前分别解锁
    defer urlMap.mux.Unlock()
    if err != nil {
        urlMap.m[url] = fmt.Sprintf("Can not find url!")
        return
    }
    urlMap.m[url] = body
    for _, u := range urls {
        // 如果cache命中，认为这个url已经爬过了，跳过他
        _, ok := urlMap.m[u]
        if(!ok) {
            // 增加一个新任务，任务在这个Go程完成后释放
            wg.Add(1)
            // 递归地爬取
            go Crawl(u, depth-1, fetcher)
        }
        
    }
    return
}

func main() {
    // 增加初始任务
    wg.Add(1)
    Crawl("https://golang.org/", 4, fetcher)
    // 阻塞主线程， 直到wg中任务数为0
    wg.Wait()
    for k, v := range urlMap.m {
        // 输出结果
        fmt.Println(k, v)
    }
}

// fakeFetcher 是返回若干结果的 Fetcher。
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 是填充后的 fakeFetcher。
var fetcher = fakeFetcher{
    "https://golang.org/": &fakeResult{
        "The Go Programming Language",
        []string{
            "https://golang.org/pkg/",
            "https://golang.org/cmd/",
        },
    },
    "https://golang.org/pkg/": &fakeResult{
        "Packages",
        []string{
            "https://golang.org/",
            "https://golang.org/cmd/",
            "https://golang.org/pkg/fmt/",
            "https://golang.org/pkg/os/",
        },
    },
    "https://golang.org/pkg/fmt/": &fakeResult{
        "Package fmt",
        []string{
            "https://golang.org/",
            "https://golang.org/pkg/",
        },
    },
    "https://golang.org/pkg/os/": &fakeResult{
        "Package os",
        []string{
            "https://golang.org/",
            "https://golang.org/pkg/",
        },
    },
}

在执行时，使用互斥锁确保了同一时间只有一个Go程在操作urlMap，具体来说，只有父页面Unlock以后，子页面才能以一个随机的顺序一一遍历，实际上，通过再传递一些优先级参数，应该能做到指定一个顺序（比如字典序）进行遍历，遍历过程实际上是一个dfs，但是使用多线程提高了效率。

总结

Go在支持Channel这种多线程编程模式的同时，也支持传统的互斥锁模式，在处理某些问题时，互斥锁会比Channel实现更加简单。需要注意的是，互斥锁实际上并非对数据加锁，而是对某个代码块加锁。使用defer命令可以确保线程结束时释放锁，需要善用。

题目描述与分析

代码实现

总结