Go指南练习-Web爬虫

go指南练习

新手初学Go语言，看到这个go指南网站在线测试很方便做了几道练习后就在上面学习。
其中最后一页的测试：
go指南练习:web爬虫
学了go的并发基本使用方法后，觉得比c的多线程好写多了，所以最后的模拟web爬虫练习的代码贴出来，希望指教下怎么写更安全、高效。

题目要求

/* 练习：Web 爬虫
在这个练习中，我们将会使用 Go 的并发特性来并行化一个 Web 爬虫。
修改 Crawl 函数来并行地抓取 URL，并且保证不重复。
提示：你可以用一个 map 来缓存已经获取的 URL，
但是要注意 map 本身并不是并发安全的！ */

// TODO: 并行的抓取 URL。
// TODO: 不重复抓取页面。
// Crawl 并没有实现上面两种情况：

修改部分

该代码其实是对伪造的fakeFetcher进行抓取，每个伪造结果map内的元素是一个结构体fakeResult。
该结构体元素由body字段（真正要展示的内容）和归属的urls。
Crawl函数调用Fetcher接口的fetcher方法对fakeResult的body字段匹配，并打印匹配到的body出来，没找到就打印报错。
若是匹配成功，Crawl深度减一递归的调用Crawl，url使用匹配body对应的fakeResult下的urls切片每一个url值。

1. 要求使用并发的实现
   所以为了不改变原函数模板采用sync.WaitGroup来进行主进程等待子进程结束。

   // sync.WaitGroup 用法
   var wg sync.WaitGroup
   wg.Add(i int) 	//添加i个worker协程
   wg.Done()		//该子进程结束，做记录
   wg.Wait() 		//当worker协程未全部执行结束，会一直堵塞
   

2. 要求使用map记录已经爬取的页面避免重复抓取
   由于map非并发安全（多个goroutine同时写入map会报错），添加互斥锁解决。

   // 带互斥锁的map，防止并行的写入
   type SafeUrlMap struct {
   	set map[string]int
   	mux sync.Mutex
   }
   
   func (myset SafeUrlMap) add(url string) {
   	myset.mux.Lock()
   	// elem, ok = set[url]
   	myset.set[url]++
   	myset.mux.Unlock()
   }
   func (myset SafeUrlMap) have(url string) bool {
   	myset.mux.Lock()
   	if myset.set[url] != 0 {
   		defer myset.mux.Unlock()
   		return true
   	}
   	return false
   }	
   

完整代码

package main

import (
	"fmt"
	"sync"
)

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) {
	if depth <= 0 {
		wg.Done()
		return
	}
	if myset.have(url) {
		wg.Done()
		return
	}

	body, urls, err := fetcher.Fetch(url)
	myset.add(url) // 无论该网页是否找到，都做一次记录防止下次重复抓取
	if err != nil {
		fmt.Println(err)
		wg.Done()
		return
	}
	fmt.Printf("found: %s %q\n", url, body)

	for _, u := range urls {
		wg.Add(1)
		go Crawl(u, depth-1, fetcher)
	}
	wg.Done()
	return
}

func main() {
	myset = SafeUrlMap{set: make(map[string]int)}
	wg.Add(1)
	Crawl("https://golang.org/", 4, fetcher)
	wg.Wait()
}

// 带互斥锁的map，防止并行的写入
type SafeUrlMap struct {
	set map[string]int
	mux sync.Mutex
}
// url记录的查询方法
func (myset SafeUrlMap) add(url string) {
	myset.mux.Lock()
	// elem, ok = set[url]
	myset.set[url]++
	myset.mux.Unlock()
}
// url记录的添加方法
func (myset SafeUrlMap) have(url string) bool {
	myset.mux.Lock()
	if myset.set[url] != 0 {
		defer myset.mux.Unlock()
		return true
	}
	return false
}

// 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)
}

// 已采集的Url清单,采集进程组
var (
	myset SafeUrlMap
	wg    sync.WaitGroup
)

// 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/",
		},
	},
}