golang之Web爬虫练习

go编程指南的题目

题目链接：https://tour.go-zh.org/concurrency/10

练习：Web 爬虫

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

修改 Crawl 函数来并行地抓取 URL，并且保证不重复。

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

package main

import (
	"fmt"
	"sync"
)

// 新增start
type UrlCounter struct {
	Urls map[string]int
	mux  sync.Mutex
}

func (uc UrlCounter) Mark(url string) {
	uc.mux.Lock()
	defer uc.mux.Unlock()
	uc.Urls[url] = 1
}

func (uc UrlCounter) CheckUrl(url string) bool {
	uc.mux.Lock()
	defer uc.mux.Unlock()
	if _, ok := uc.Urls[url]; ok {
		return true
	} else {
		return false
	}
}

var urlCounter UrlCounter

// 新增end

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
	}
	// 避免重复
	if urlCounter.CheckUrl(url) {
		return
	}
	body, urls, err := fetcher.Fetch(url)
  // 标记爬取过的url
	urlCounter.Mark(url)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("found: %s %q\n", url, body)
	ch := make(chan int)
	for _, u := range urls {
		// 改成并发
		go func(url string) {
			Crawl(url, depth-1, fetcher)
			ch <- 1
		}(u)
	}
	// 等待协程运行结束
	for range urls {
		<-ch
	}
	return
}

func main() {
	urlCounter = UrlCounter{Urls: make(map[string]int)}
	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/",
		},
	},
}

输出：

found: https://golang.org/ "The Go Programming Language"
not found: https://golang.org/cmd/
found: https://golang.org/pkg/ "Packages"
found: https://golang.org/pkg/os/ "Package os"
found: https://golang.org/pkg/fmt/ "Package fmt"

注意其中的并发写法：

go func(url string) {
    Crawl(url, depth-1, fetcher)
    ch <- 1
}(u)

需要将url传入，而不能采用如下的写法：

go func() {
    Crawl(u, depth-1, fetcher)
    ch <- 1
}()

原因是起来之后都共用了同一个外层的u变量，而这个u变量是受到for循环的影响的，导致输出结果的减少。

其中，协程必须要用一个阻塞等待协程运行结束，否则协程会直接被杀死。

当然也可以用别的方法等待

比如在main函数用个死循环

// Crawl 使用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。
func Crawl(url string, depth int, fetcher Fetcher) {
	// TODO: 并行的抓取 URL。
	// TODO: 不重复抓取页面。
	// 下面并没有实现上面两种情况：
	if depth <= 0 {
		return
	}
	// 避免重复
	if urlCounter.CheckUrl(url) {
		return
	}
	body, urls, err := fetcher.Fetch(url)
  // 标记爬取过的url
	urlCounter.Mark(url)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("found: %s %q\n", url, body)
	//ch := make(chan int)
	for _, u := range urls {
		// 改成并发
		go func(url string) {
			Crawl(url, depth-1, fetcher)
			//ch <- 1
		}(u)
	}
	// 等待协程运行结束
	for range urls {
		//<-ch
	}
	return
}

func main() {
	urlCounter = UrlCounter{Urls: make(map[string]int)}
	Crawl("https://golang.org/", 4, fetcher)
	for {}
}

使用sync.Map

需要并发读写时，一般的做法是加锁，但这样性能并不高，Go语言在 1.9 版本中提供了一种效率较高的并发安全的 sync.Map，sync.Map 和 map 不同，不是以语言原生形态提供，而是在 sync 包下的特殊结构。

sync.Map 有以下特性：

• 无须初始化，直接声明即可。
• sync.Map 不能使用 map 的方式进行取值和设置等操作，而是使用 sync.Map 的方法进行调用，Store 表示存储，Load 表示获取，Delete 表示删除。
• 使用 Range 配合一个回调函数进行遍历操作，通过回调函数返回内部遍历出来的值，Range 参数中回调函数的返回值在需要继续迭代遍历时，返回 true，终止迭代遍历时，返回 false。

package main

import (
	"fmt"
	"sync"
)

// 新增start
var urlCounter sync.Map
// 新增end

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
	}
	// 避免重复
	if _, ok := urlCounter.Load(url); ok {
		return
	}
	body, urls, err := fetcher.Fetch(url)
	// 标记爬取过的url
	urlCounter.Store(url, 1)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("found: %s %q\n", url, body)
	ch := make(chan int)
	for _, u := range urls {
		// 改成并发
		go func(url string) {
			Crawl(url, depth-1, fetcher)
			ch <- 1
		}(u)
	}
	// 等待协程运行结束
	for range urls {
		<-ch
	}
	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/",
		},
	},
}

使用sync.WaitGroup

WaitGroup能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。
WaitGroup总共有三个方法：Add(delta int)，Done()，Wait()。简单的说一下这三个方法的作用。
Add：添加或者减少等待goroutine的数量；
Done：相当于Add(-1)；
Wait：执行阻塞，直到所有的WaitGroup数量变成 0
这边使用WaitGroup替代channel进行阻塞等待

package main

import (
	"fmt"
	"sync"
)

// 新增start
var urlCounter sync.Map

// 新增end

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
	}
	// 避免重复
	if _, ok := urlCounter.Load(url); ok {
		return
	}
	body, urls, err := fetcher.Fetch(url)
	// 标记爬取过的url
	urlCounter.Store(url, 1)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("found: %s %q\n", url, body)
	//ch := make(chan int)
	wg := &sync.WaitGroup{}
  // 或 var wg sync.WaitGroup
	for _, u := range urls {
		// 改成并发
		wg.Add(1)
		go func(url string, wg *sync.WaitGroup) {
			Crawl(url, depth-1, fetcher)
			wg.Done()
		}(u, wg)
	}
	// 等待协程运行结束
	//for range urls {
	//	<-ch
	//}
	wg.Wait()
  
	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/",
		},
	},
}