在Go的并发编程中有一句很经典的话：不要以共享内存的方式去通信，而要以通信的方式去共享内存。
在Go语言中并不鼓励用锁保护共享状态的方式在不同的Goroutine中分享信息(以共享内存的方式去通信)。而是鼓励通过channel将共享状态或共享状态的变化在各个Goroutine之间传递（以通信的方式去共享内存），这样同样能像用锁一样保证在同一的时间只有一个Goroutine访问共享状态。
当然，在主流的编程语言中为了保证多线程之间共享数据安全性和一致性，都会提供一套基本的同步工具集，如锁，条件变量，原子操作等等。Go语言标准库也毫不意外的提供了这些同步机制，使用方式也和其他语言也差不多。
WaitGroup
WaitGroup，同步等待组。
在类型上，它是一个结构体。一个WaitGroup的用途是等待一个goroutine的集合执行完成。主goroutine调用了Add()方法来设置要等待的goroutine的数量。然后，每个goroutine都会执行并且执行完成后调用Done()这个方法。与此同时，可以使用Wait()方法来阻塞，直到所有的goroutine都执行完成。
Add()方法
Add这个方法，用来设置到WaitGroup的计数器的值。我们可以理解为每个waitgroup中都有一个计数器 用来表示这个同步等待组中要执行的goroutin的数量。
如果计数器的数值变为0，那么就表示等待时被阻塞的goroutine都被释放，如果计数器的数值为负数，那么就会引发恐慌，程序就报错了。
Done()方法
Done()方法，就是当WaitGroup同步等待组中的某个goroutine执行完毕后，设置这个WaitGroup的counter数值减1。
Wait()方法
Wait()方法，表示让当前的goroutine等待，进入阻塞状态。一直到WaitGroup的计数器为零。才能解除阻塞， 这个goroutine才能继续执行。
示例代码
package main import ( "fmt" "sync" ) var wg sync.WaitGroup // 创建同步等待组对象 func main() { /* WaitGroup：同步等待组 可以使用Add(),设置等待组中要 执行的子goroutine的数量， 在main 函数中，使用wait(),让主程序处于等待状态。直到等待组中子程序执行完毕。解除阻塞 子gorotuine对应的函数中。wg.Done()，用于让等待组中的子程序的数量减1 */ //设置等待组中，要执行的goroutine的数量 wg.Add(2) go fun1() go fun2() fmt.Println("main进入阻塞状态。。。等待wg中的子goroutine结束。。") wg.Wait() //表示main goroutine进入等待，意味着阻塞 fmt.Println("main，解除阻塞。。") } func fun1() { for i:=1;i<=10;i++{ fmt.Println("fun1.。。i:",i) } wg.Done() //给wg等待中的执行的goroutine数量减1.同Add(-1) } func fun2() { defer wg.Done() for j:=1;j<=10;j++{ fmt.Println("\tfun2..j,",j) } }channel通道
通道可以被认为是Goroutines通信的管道。类似于管道中的水从一端到另一端的流动，数据可以从一端发送到另一端，通过通道接收。
在前面讲Go语言的并发时候，我们就说过，当多个Goroutine想实现共享数据的时候，虽然也提供了传统的同步机制，但是Go语言强烈建议的是使用Channel通道来实现Goroutines之间的通信。
“不要通过共享内存来通信，而应该通过通信来共享内存” 这是一句风靡golang社区的经典语
接收和发送
一个通道发送和接收数据，默认是阻塞的。当一个数据被发送到通道时，在发送语句中被阻塞，直到另一个Goroutine从该通道读取数据。相对地，当从通道读取数据时，读取被阻塞，直到一个Goroutine将数据写入该通道。
示例代码：以下代码加入了睡眠，可以更好的理解channel的阻塞
package main import ( "fmt" "time" ) func main() { ch1 := make(chan int) done := make(chan bool) // 通道 go func() { fmt.Println("子goroutine执行。。。") time.Sleep(3 * time.Second) data := <-ch1 // 从通道中读取数据 fmt.Println("data：", data) done <- true }() // 向通道中写数据。。 time.Sleep(5 * time.Second) ch1 <- 100 <-done fmt.Println("main。。over") }在上面的程序中，我们先创建了一个chan bool通道。然后启动了一条子Goroutine，并循环打印10个数字。然后我们向通道ch1中写入输入true。
然后在主goroutine中，我们从ch1中读取数据。这一行代码是阻塞的，这意味着在子Goroutine将数据写入到该通道之前，主goroutine将不会执行到下一行代码。
因此，我们可以通过channel实现子goroutine和主goroutine之间的通信。当子goroutine执行完毕前，主goroutine会因为读取ch1中的数据而阻塞。从而保证了子goroutine会先执行完毕。这就消除了对时间的需求。
在之前的程序中，我们要么让主goroutine进入睡眠，以防止主要的Goroutine退出。要么通过WaitGroup来保证子goroutine先执行完毕，主goroutine才结束。
死锁
使用通道时要考虑的一个重要因素是死锁。如果Goroutine在一个通道上发送数据，那么预计其他的Goroutine应该接收数据。如果这种情况不发生，那么程序将在运行时出现死锁。
类似地，如果Goroutine正在等待从通道接收数据，那么另一些Goroutine将会在该通道上写入数据，否则程序将会死锁。
示例代码
package main func main() { ch := make(chan int) ch <- 5 }报错：
fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan send]: main.main() /Users/ruby/go/src/l_goroutine/demo08_chan.go:5 +0x50Goroutine
Goroutine 是实际并发执行的实体，它底层是使用协程(coroutine)实现并发，coroutine是一种运行在用户态的用户线程，类似于 greenthread，go底层选择使用coroutine的出发点是因为，它具有以下特点：
用户空间 避免了内核态和用户态的切换导致的成本
可以由语言和框架层进行调度
更小的栈空间允许创建大量的实例
Goroutine 调度器
Go并发调度: G-P-M模型
在操作系统提供的内核线程之上，Go搭建了一个特有的两级线程模型。goroutine机制实现了M : N的线程模型，goroutine机制是协程（coroutine）的一种实现，golang内置的调度器，可以让多核CPU中每个CPU执行一个协程。
以上内容来自 https://github.com/rubyhan1314/Golang-100-Days
主要说明一下同步等待组和通道的基本使用，以及 go 是如何处理并发的，更多可以继续参考以上，来自千峰的 go 教程。
实战爬虫
前面说了这么多只不过是为这个脚本做铺垫，要不然则来的太唐突。
我这里写了一个爬虫脚本，用到了通道来做并发，并有同步等待组做 awit() 操作
直接来看代码
获取html
func HttpGet(url string) (result string, err error) { resp, err1 := http.Get(url) if err != nil { err = err1 return } defer resp.Body.Close() //读取网页的body内容 buf := make([]byte, 4*1024) for true { n, err := resp.Body.Read(buf) if err != nil { if err == io.EOF{ break }else { fmt.Println("resp.Body.Read err = ", err) break } } result += string(buf[:n]) } return }爬取网页存为 .html 文件
func spiderPage(url string) string { fmt.Println("正在爬取", url) //爬,将所有的网页内容爬取下来 result, err := HttpGet(url) if err != nil { fmt.Println(err) } //把内容写入到文件 filename := strconv.Itoa(rand.Int()) + ".html" f, err1 := os.Create(filename) if err1 != nil{ fmt.Println(err1) } //写内容 f.WriteString(result) //关闭文件 f.Close() return url + " 抓取成功" }爬取方法方面就写完了，接下来就到了重要的部分了
定义一个工作者函数
func doWork(start, end int,wg *sync.WaitGroup) { fmt.Printf("正在爬取第%d页到%d页\n", start, end) //因为很有可能爬虫还没有结束下面的循环就已经结束了，所以这里就需要且到通道 page := make(chan string,100) results := make(chan string,100) go sendResult(results,start,end) go func() { for i := 0; i <= 20; i++ { wg.Add(1) go asyn_worker(page, results, wg) } }() for i := start; i <= end; i++ { url := "https://tieba.baidu.com/f?kw=%E7%BB%9D%E5%9C%B0%E6%B1%82%E7%94%9F&ie=utf-8&pn=" + strconv.Itoa((i-1)*50) page <- url println("加入" + url + "到page") } println("关闭通道") close(page) wg.Wait() //time.Sleep(time.Second * 5) println(" Main 退出 。。。。。") }从通道取出数据
func asyn_worker(page chan string, results chan string,wg *sync.WaitGroup){ defer wg.Done() //defer wg.Done()必须放在go并发函数内 for{ v, ok := <- page //显示的调用close方法关闭通道。 if !ok{ fmt.Println("已经读取了所有的数据，", ok) break } //fmt.Println("取出数据：",v, ok) results <- spiderPage(v) } //for n := range page { // results <- spiderPage(n) //} }发送抓取结果
func sendResult(results chan string,start,end int) { //for i := start; i <= end; i++ { // fmt.Println(<-results) //} // 发送抓取结果 for{ v, ok := <- results if !ok{ fmt.Println("已经读取了所有的数据，", ok) break } fmt.Println(v) } }大体思路是这样的：
可以看到我定义了两个通道，一个是用来存入 url 的，另一个是用来存入爬取结果的，缓冲空间是 100
在方法 doWork 中， sendResult 会阻塞等待 results 通道的输出，匿名函数则是等待 page 通道的输出
紧接着下面就是把 200 个 url 写入 page 通道，匿名函数得到 page 的输出就会执行 asyn_worker 函数，也就是爬取 html 的函数了(将其存入results 通道)
然后 sendResult 函数得到 results 通道的输出，将结果打印出来
可以看到 我在匿名函数中并发了 20 个 goroution，并且启用了同步等待组作为参数传入，理论上可以根据机器的性能来定义 并发数
main函数
运行爬虫并计算运行时间，这个时间因机器而异，但应该不会相差太多
完整代码
总体来说，这个脚本就是为了弄清楚 Go 语言的并发原理 以及 通道，同步等待组的基本使用，或者只用 go 语言的锁，目的都是为了防止 临界资源的安全问题。
有了 channel 和 goroutine 之后，Go 的并发编程变得异常容易和安全，得以让程序员把注意力留到业务上去，实现开发效率的提升。