Golang学习笔记：体验Go的并发编程（二）

在Go指南中，最后一节的练习是一个WEB爬虫。刚开始看目录以为真的是要写一个爬虫，直到仔细阅读了代码才发现，只是让利用channel和mutex模拟一个爬虫的代码。

初始状态如下

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("http://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{
	"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/",
		},
	},
}

fetcher在初始化时就已经将爬虫的爬取信息写死了，教程所要实现的是：并行爬取和同步控制

对于并行爬取，我的思路是每层根据宽度创建相应的线程进行递归爬取。实现起来比较简单就是在for循环中创建线程递归执行Crawl函数

同步控制根据提示知道利用sync.Mutex做个信号量，更新与查询路径表的时候保证同步即可。

实现的代码如下

package main

import (
	"fmt"
	"sync"
)

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

type walk struct {
	m   map[string]int
	mux sync.Mutex
}

// Crawl 使用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。
func Crawl(url string, depth int, fetcher Fetcher) {
	if depth <= 0 {
		return
	}
	var wg = sync.WaitGroup{}
	var body string
	var urls []string
	var err error
	//Lock
	haswalk.mux.Lock()
	if _, ok := haswalk.m[url]; !ok {
		body,urls,err=fetcher.Fetch(url)
		haswalk.m[url] = 1
		if err != nil {
			fmt.Println(err)
			haswalk.mux.Unlock()
			return
		}
		fmt.Printf("found: %s %q\n", url, body)

	}else{
		haswalk.mux.Unlock()
		return
	}
	haswalk.mux.Unlock()
	for _, u := range urls {
		//增加一条等待线程
		wg.Add(1)
		go func(target string,d int,fet Fetcher) {
			//递归爬取
			Crawl(target, d, fet)
			wg.Done()
		}(u,depth-1,fetcher)
	}
	wg.Wait()
	return
}

func main() {
	Crawl("http://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)
}

//抓取路径
var haswalk = walk{m: make(map[string]int)}

// fetcher 是填充后的 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/",
		},
	},
}

完成这段代码花费了半天的时间（真心太渣了T_T），其中有两个坑，坑了我好久。

首先是，主线程提前结束，导致整个程序只爬取了一层后退出。

解决方法也很简单，利用WaitGroup实现信号量机制，没创建一个新线程就增加一条信号量记录，当前线程在所有创建的线程都执行完毕后才会结束。

其次是，在并行爬取的过程中，刚开始的的写法是

	for _, u := range urls {
		//增加一条等待线程
		wg.Add(1)
		go func() {
			//递归爬取
			Crawl(u, depth-1, fetcher)
			wg.Done()
		}()
	}

看上去没什么问题，但是执行过程中发现，参数u的值，按道理来说应该是urls中的每条记录，但是实际执行时，每次u都是urls中的最后一条记录。

我猜测应该是子线程在获取u的值的时候，u已经遍历到了最后一条记录，所以每次取都只会是最后一条记录的结果。

写法改成

	for _, u := range urls {
		//增加一条等待线程
		wg.Add(1)
		go func(target string,d int,fet Fetcher) {
			//递归爬取
			Crawl(target, d, fet)
			wg.Done()
		}(u,depth-1,fetcher)
	}
	wg.Wait()

goroutine执行的函数增加三个参数后，先将参数传过去，就正常了。

总算是完成了Go指南中的练习了！！！Go的语法和C还是挺像的，理解起来不算太难。在并发编程这里，感觉自己的思想还是有问题，太稚嫩！写这个假爬虫的过程发现了好多前人踩过的坑我还在踩，各种死锁、同步的问题其实都可以避免的～～～

写这段代码用的三idea的goland，在调试过程中发现断点只对当前线程有用，没有办法设置成将所有线程都挂起T_T，如果有大神知道怎么设置，跪求！！！

有疑问加站长微信联系（非本文作者）