GO语言的进阶之路-协程和Channel

　　　　　　　　　　　　　　　　　　　　　　　　GO语言的进阶之路-协程和Channel

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

　　　看过我之前几篇博客小伙伴可能对Golang语言的语法上了解的差不多了，但是，如果想要你的代码和性能更高，那还得学点晋升的本来，这个时候我们就需要引入Golang的协成这个概念了，其实，你可能早就听说了Golang的优势就是处理大并发，我们可以用它来做日志收集系统，也可以用它做业务上的“秒杀系统”，当然我们还可以用它来做“监控系统”。好了，下面跟我一起来体会一下Golang的五味杂陈吧。

 

一.什么是协程；

　　再说协成之前，我们需要了解两个概念，即用户态和内核态。

1.什么是用户态；

　　官方解释：用户态（user mode）在计算机结构指两项类似的概念。在CPU的设计中，用户态指非特权状态。在此状态下，执行的代码被硬件限定，不能进行某些操作，比如写入其他进程的存储空间，以防止给操作系统带来安全隐患。在操作系统的设计中，用户态也类似，指非特权的执行状态。内核禁止此状态下的代码进行潜在危险的操作，比如写入系统配置文件、杀掉其他用户的进程、重启系统等。

 　　应用程序在用户态下运行，仅仅只能执行cpu整个指令集的一个子集，该子集中不包含操作硬件功能的部分，因此，一般情况下，在用户态中有关I/O和内存保护（操作系统占用的内存是受保护的，不能被别的程序占用）。

　　如果感兴趣的朋友可以参考：https://baike.baidu.com/item/%E7%94%A8%E6%88%B7%E6%80%81/9548791?fr=aladdin

 

2.什么是内核态；

　　内核态也叫和核心态。

　　官方解释：在处理器的存储保护中，主要有两种权限状态，一种是核心态（管态），也被称为特权态；一种是用户态（目态）。核心态是操作系统内核所运行的模式，运行在该模式的代码，可以无限制地对系统存储、外部设备进行访问。

　　操作系统在内核态运行情况下可以访问硬件上所有的内容。

　　如果感兴趣的朋友可以参考：https://baike.baidu.com/item/%E6%A0%B8%E5%BF%83%E6%80%81/6845908?fr=aladdin

 

3.什么是协成;

　　官方解释：一个程序可以包含多个协程，可以对比与一个进程包含多个线程，因而下面我们来比较协程和线程。我们知道多个线程相对独立，有自己的上下文，切换受系统控制；而协程也相对独立，有自己的上下文，但是其切换由自己控制，由当前协程切换到其他协程由当前协程来控制。

　　协程（coroutine）是Go语言中的轻量级线程实现，由Go运行时（runtime）管理。在一个函数调用前加上go关键字，这次调用就会在一个新的goroutine中并发执行。当被调用的函数返回时，这个goroutine也自动结束。需要注意的是，如果这个函数有返回值，那么这个返回值会被丢弃。协成工作在用户态，它类似于现场的运行方式可以并行处理任务。

　  如果感兴趣的朋友可以参考：http://baike.baidu.com/link?url=MKRg3Ca7Bokkqv5EarU1JO7Oz6Wn8jMhmJcoivDG27dOFeznk3gVDSl5SfN6P191GSwGDInEfDPVkQ6j3pJNbICpy04U0F1TkLOZHVzs1-u

 

二.创建一个协程；

　　 在一个函数调用前加上go关键字，这次调用就会在一个新的goroutine中并发执行，下面我们一起来看段代码的执行结果：

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11 "time"
12 "fmt"
13 )
14 
15 func sayhi(s string)  {
16     for i := 0; i < 5; i++ {
17         time.Sleep(100*time.Millisecond)  //表示每次循环后都要休息100毫秒。
18         fmt.Println(s)
19     }
20 }
21 
22 func main() {
23     go sayhi("尹正杰")  //在函数执行前加个go，表示单独起了一个协程，表示和当前主协程（main）并驾齐驱运行代码。
24     sayhi("Golang")
25 }
26 
27 
28 #以上代码执行结果如下：
29 Golang
30 尹正杰
31 尹正杰
32 Golang
33 Golang
34 尹正杰
35 尹正杰
36 Golang
37 Golang
38 尹正杰

 　　相信大家已经看到了一些端倪，我们先定义了一个“sayhi”函数，这个函数的功能就是将传入的字符串打印5遍，然后我们在主程序上调用的时候，发现在函数面前加"go"关键字时，就会打印输出，但是奇怪的是没有按照顺序打，它没有先打印五遍“尹正杰”然后在打印5遍“Golang”,而是函数执行结果是不规律的打印了两个字符串。这就是并发的效果，两个函数同事运行效果。这也是我们的并发之路的初体验。哈哈~

 

 

三.协程的局限性;

　　发现让两端代码同事运行貌似听起来很高大上的样子，但是有个局限性，就是当主进程结束后，协成也会跟着结束，其实这个很好理解，我们通过一段代码就知道了：

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13 )
14 
15 func main() {
16     s := []int{2,7,1,6,4,3,11,15,17,5,8,9,12}
17     for _,n := range s{
18         go func(n int) { //定义一个匿名函数，并对该函数开启协程，每次循环都会开启一个协成，也就是说它开启了13个协程。
19             time.Sleep(time.Duration(n) * time.Second) /*表示每循环一次就需要睡1s，睡的总时间是由n来控制的，
20             总长度是由s切片数组中最大的一个数字决定，也就是说这个协成最少需要17秒才会结束哟*/
21             fmt.Println(n)
22         }(n)  //由于这个函数是匿名函数，所以调用方式就直接：（n）调用，不用输入函数名。
23     }
24     time.Sleep(12*time.Second) //主进程要执行的时间是12秒
25 }
26 
27 
28 
29 #以上代码执行结果如下：
30 1
31 2
32 3
33 4
34 5
35 6
36 7
37 8
38 9
39 11
40 12

　　是不是很神奇，直接就进行排序了，但是15和17没有在终端输出，为什么呢？这就是我所说的主进程结束，那么整个程序也终将结束，因为主程序的时间只有12s，如果你想让所有的数据都排序出来，就得把数字换成一个大于或等于17的，这样才会对所有的数字进行排序。因为协成13个协程都要执行完毕的话需要17s才好使。

 

四.锁；

1.为什么要引入锁；

　　在线上生活中，我们为了避免多个用户操作同一个文件，就会定义一个锁，为什么我们需要一个锁呢？我们可以看以下的案例：

 1 package main
 2 
 3 import (
 4     "time"
 5     "fmt"
 6 )
 7 
 8 type Accout struct {
 9     money int
10 }
11 
12 func (a *Accout) Do_Prepare() {
13     time.Sleep(time.Second)
14 }
15 
16 func (a *Accout) Get_Gongzi(n int) {
17     a.money += n
18 }
19 
20 func (a *Accout) Give_Wife(n int) {
21     if a.money > n {
22         a.Do_Prepare()
23         a.money -= n
24     }
25 }
26 
27 func (a *Accout) Buy(n int) {
28     if a.money >n {
29         a.Do_Prepare()
30         a.money -= n
31     }
32 }
33 
34 func (a *Accout) Left()int {
35     return a.money
36 }
37 
38 func main() {
39     var   account Accout
40     account.Get_Gongzi(10000)
41     go account.Give_Wife(6000)
42     go account.Buy(5000)
43     time.Sleep(2 * time.Second) //不能让主程序结束掉，因为主进程一结束go的协程也就跟着结束啦。
44     fmt.Println(account.Left())
45 }
46 
47 
48 
49 #以上代码执行结果如下：
50 -1000

 

　　估计大家都看出来端倪了，在让两个协程并发跑起来，发现你得到的10000块钱都让给花出去了，是不是老尴尬了，写的判断语句也是没有生效的，最终10000块钱的工资，它竟然花了11000，如果银行这么干早就倒闭了，哈哈~那么问题来了，如果解决这一种现象呢？目前有四种常见的处理方案即：互斥锁，读写锁和channel锁以及waitgroup等等。

 

2.互斥锁；

　　互斥锁是传统的并发程序对共享资源进行访问控制的主要手段。它由标准库代码包sync中的Mutex结构体类型代表。sync.Mutex类型（确切地说，是*sync.Mutex类型）只有两个公开方法——Lock和Unlock。顾名思义，前者被用于锁定当前的互斥量，而后者则被用来对当前的互斥量进行解锁。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13     "sync"
14 )
15 
16 
17 type Accout struct {
18     flag sync.Mutex
19     money int
20 }
21 
22 func (a *Accout) Do_Prepare() {
23     time.Sleep(time.Second)
24 }
25 
26 func (a *Accout) Get_Salary(n int) { //定义发的工资
27     a.money += n
28 }
29 
30 func (a *Accout) Give_Wife(n int) {  //上交给妻子的工资
31     a.flag.Lock()
32     defer a.flag.Unlock()
33     if a.money > n {
34         a.Do_Prepare()
35         a.money -= n
36     }else {
37         fmt.Println("您的余额已不足！请及时充值~")
38     }
39 }
40 
41 func (a *Accout) Buy(n int) {  //自己买的工资
42     a.flag.Lock()
43     defer a.flag.Unlock()
44     if a.money >n {
45         a.Do_Prepare()
46         a.money -= n
47     }else {
48         fmt.Println("您的余额已不足！请及时充值~")
49     }
50 }
51 
52 func (a *Accout) Left()int {
53     return a.money
54 }
55 
56 func main() {
57     var   account Accout
58     account.Get_Salary(10000)
59     go account.Give_Wife(6000)
60     go account.Buy(5000)
61     time.Sleep(2 * time.Second) //不能让主程序结束掉，因为主进程一结束go的协程也就跟着结束啦。
62     fmt.Printf("您的剩余工资是\033[31;1m%d\033[0m",account.Left())
63 
64 }
65 
66 
67 
68 #以上代码解析如下：
69 您的余额已不足！请及时充值~
70 您的剩余工资是4000

 

 

3.读写锁；

　　在Go语言中，读写锁由结构体类型sync.RWMutex代表。与互斥锁类似，sync.RWMutex类型的零值就已经是立即可用的读写锁了。

　　读写锁即是针对于读写操作的互斥锁。它与普通的互斥锁最大的不同就是，它可以分别针对读操作和写操作进行锁定和解锁操作。读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的。但是，多个读操作之间却不存在互斥关系。

 

A.多个读操作之间却不存在互斥关系;

　　我们会发现读取操作没有存在互斥的关系。5个进程同事进行读取，最终都顺利并行跑完了。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "sync"
12     "time"
13 )
14 
15 var m *sync.RWMutex  //定义m的类型为读写锁。
16 
17 func main() {
18     m = new(sync.RWMutex)
19     go read("第一次读取：")  //开启5个协程进行读取操作。如果不能并发跑最少需要5秒钟时间。
20     go read("第二次读取：")
21     go read("第三次读取：")
22     go read("第四次读取：")
23     go read("第五次读取：")
24     time.Sleep(2* time.Second)  //主进程只有2s，意味着这个程序最多能运行2s的时间。
25 }
26 
27 func read(i string) {
28     println(i, "read start")
29     m.RLock()  //读锁定
30     println(i, "资料正在读取中....")
31     time.Sleep(1 * time.Second)  //改函数执行完毕最少需要睡1秒。
32     m.RUnlock() //读解锁
33     println(i, "read end")
34 }
35 
36 
37 
38 #以上代码执行结果如下：
39 第二次读取： read start
40 第二次读取： 资料正在读取中....
41 第一次读取： read start
42 第一次读取： 资料正在读取中....
43 第三次读取： read start
44 第三次读取： 资料正在读取中....
45 第四次读取： read start
46 第四次读取： 资料正在读取中....
47 第五次读取： read start
48 第五次读取： 资料正在读取中....
49 第一次读取： read end
50 第三次读取： read end
51 第二次读取： read end
52 第四次读取： read end
53 第五次读取： read end

 

 

B.读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的;

　　我们发现，读的时候不能写，写的时候不能读，我们将主程序设置的时间是10秒钟，一次读两次写花费的总时间是12秒钟，因此肯定有一个是无法完成度或是写的部分。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "sync"
12     "time"
13 )
14 
15 var m *sync.RWMutex
16 
17 func read(i string) {
18     println(i, "read start")
19     m.RLock()
20     println(i, "资料正在读取中.....")
21     time.Sleep(4 * time.Second)
22     m.RUnlock()
23     println(i, "read end")
24 }
25 
26 func write(i string) {
27     println(i, "write start")
28     m.Lock() //写操作锁定
29     println(i, "数据正在写入硬盘中.....")
30     time.Sleep(4 * time.Second)
31     m.Unlock()  //写操作解锁
32     println(i, "write end")
33 }
34 
35 func main(){
36     m = new(sync.RWMutex)
37     go write("第一次写入") //写的时候啥都不能干,即其他协程无法写入，也无法读取。
38     go read("第一次读取")
39     go write("第二次写入")
40     time.Sleep(10 * time.Second) //主进程只给出10秒的时间，但是整个进程跑完最少需要12秒的时间。
41 }
42 
43 
44 
45 
46 #以上代码直接结果如下：
47 第一次写入 write start
48 第一次写入 数据正在写入硬盘中.....
49 第一次读取 read start
50 第二次写入 write start
51 第一次写入 write end
52 第一次读取 资料正在读取中.....
53 第一次读取 read end
54 第二次写入 数据正在写入硬盘中.....

 

4.channel锁;

　　channel锁的工作原理就是让2个协成互相通信，一会我们会详细介绍。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13     "sync"
14 )
15 
16 
17 type Accout struct {
18     flag sync.Mutex
19     money int
20 }
21 
22 func (a *Accout) Do_Prepare() {
23     time.Sleep(time.Second)
24 }
25 
26 func (a *Accout) Get_Gongzi(n int) {
27     a.money += n
28 }
29 
30 func (a *Accout) Give_Wife(n int) {
31     a.flag.Lock()
32     defer a.flag.Unlock()
33     if a.money > n {
34         a.Do_Prepare()
35         a.money -= n
36     }else {
37         fmt.Println("您的余额已不足，请及时充值！")
38     }
39 }
40 
41 func (a *Accout) Buy(n int) {
42     a.flag.Lock()
43     defer a.flag.Unlock()
44     if a.money >n {
45         a.Do_Prepare()
46         a.money -= n
47     }else {
48         fmt.Println("您的余额已不足，请及时充值！")
49     }
50 }
51 
52 func (a *Accout) Left()int {
53     return a.money
54 }
55 
56 func main() {
57     var   account Accout
58     account.Get_Gongzi(10000)
59 
60     var work_info  chan string
61     work_info = make(chan string ,2)  //定义一个channel
62 
63     go func() {
64         account.Give_Wife(6000)
65         work_info <- "I done"  //如果该进程执行完毕就发送一条数据给channel，下面的那个也一样
66     }()
67 
68     go func() {
69         account.Buy(50000)
70         work_info <- "I  have done too!"
71     }()
72 
73     cnt := 0
74     for i := range work_info {
75         fmt.Println(i)
76         cnt++ //每次循环都叠加1，当2个协程都工作完就让主程序结束。
77         if cnt >= 2 {
78             break
79         }
80 
81     }
82     defer close(work_info)
83     fmt.Printf("您的剩余工资是\033[31;1m%d\033[0m",account.Left())
84 }
85 
86 
87 
88 
89 #以上代码直接结果如下：
90 您的余额已不足，请及时充值！
91 I  have done too!
92 I done
93 您的剩余工资是4000

 

　　其实channel还有一个好处就是解决超时问题，就是如果在规定的时间没有完成进程的内容，我们就返回给用户超时的状态。以下是示例代码：

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13     "sync"
14 )
15 
16 
17 type Accout struct {
18     flag sync.Mutex
19     money int
20 }
21 
22 func (a *Accout) Do_Prepare() {
23     time.Sleep(time.Second)
24 }
25 
26 func (a *Accout) Get_Gongzi(n int) {
27     a.money += n
28 }
29 
30 func (a *Accout) Give_Wife(n int) {
31     a.flag.Lock()
32     defer a.flag.Unlock()
33     if a.money > n {
34         a.Do_Prepare()
35         a.money -= n
36     }else {
37         fmt.Println("您的余额已不足，请及时充值！")
38     }
39 }
40 
41 func (a *Accout) Buy(n int) {
42     a.flag.Lock()
43     defer a.flag.Unlock()
44     if a.money >n {
45         a.Do_Prepare()
46         a.money -= n
47     }else {
48         fmt.Println("您的余额已不足，请及时充值！")
49     }
50 }
51 
52 func (a *Accout) Left()int {
53     return a.money
54 }
55 
56 func main() {
57     var   account Accout
58     account.Get_Gongzi(10000)
59 
60     var work_info  chan string
61     work_info = make(chan string ,2)  //定义一个channel
62 
63     go func() {
64         account.Give_Wife(6000)
65         work_info <- "I done"  //如果该进程执行完毕就发送一条数据给channel，下面的那个也一样
66     }()
67 
68     go func() {
69         account.Buy(50000)
70         work_info <- "I  have done too!"
71     }()
72 
73     cnt := 0
74     for i := range work_info {
75         fmt.Println(i)
76         cnt++ //每次循环都叠加1，当2个协程都工作完就让主程序结束。
77         if cnt >= 2 {
78             fmt.Println("操作超时")
79             return
80         }
81 
82     }
83     defer close(work_info)
84     fmt.Printf("您的剩余工资是\033[31;1m%d\033[0m",account.Left())
85 }
86 
87 
88 
89 #以上代码执行结果如下：
90 您的余额已不足，请及时充值！
91 I  have done too!
92 I done
93 操作超时

 

5.waitgroup进行同步；

　　WaitGroup在go语言中，用于线程同步，它能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13     "sync"
14 )
15 
16 type Accout struct {
17     flag sync.Mutex
18     money int
19 }
20 
21 func (a *Accout) Do_Prepare() {
22     time.Sleep(time.Second)
23 }
24 
25 func (a *Accout) Get_Gongzi(n int) {
26     a.money += n
27 }
28 
29 func (a *Accout) Give_Wife(n int) {
30     a.flag.Lock()
31     defer a.flag.Unlock()
32     if a.money > n {
33         a.Do_Prepare()
34         a.money -= n
35     }else {
36         fmt.Println("您的余额已不足，请及时充值！")
37     }
38 }
39 
40 func (a *Accout) Buy(n int) {
41     a.flag.Lock()
42     defer a.flag.Unlock()
43     if a.money >n {
44         a.Do_Prepare()
45         a.money -= n
46     }else {
47         fmt.Println("您的余额已不足，请及时充值！")
48     }
49 }
50 
51 func (a *Accout) Left()int {
52     return a.money
53 }
54 
55 func main() {
56     var   account Accout
57     account.Get_Gongzi(10000)
58     wg := new(sync.WaitGroup) //定义一个WaitGroup，就是用来等待都
59     wg.Add(2) //有几个进程需要等待就写几个，写多或写少都会报错哟～
60     go func() {
61         account.Give_Wife(6000)
62         wg.Done() //该进程结束就发送结束标志。
63     }()
64     go func() {
65         account.Buy(5000)
66         wg.Done()
67     }()
68     wg.Wait()  //等待所有协程结束后在执行以下都代码。
69     fmt.Printf("您的剩余工资是\033[31;1m%d\033[0m",account.Left())
70 }
71 
72 
73 
74 #以上代码执行结果如下：
75 您的余额已不足，请及时充值！
76 您的剩余工资是5000 

 

五.协程池；

　　协程池可以控制并行度，复用协程。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "sync"
12     "net/http"
13     "log"
14 )
15 
16 func work(ch chan string, wg *sync.WaitGroup) { //ch是用来接受数据，wg是用来同步协程的.
17     for u := range ch{
18         resp,err := http.Get(u) //将channel中的数据读取出来
19         if err != nil {
20             log.Print(err)
21             return
22         }
23         log.Printf("访问的网站是：%s，网页的大小是:%v",u,resp.ContentLength)
24         resp.Body.Close() //
25     }
26     wg.Done()
27 }
28 
29 func main() {
30     wg := new(sync.WaitGroup) //定义WaitGroup为了进行协程同步。
31     wg.Add(5) //开启5个协程池。
32     taskch := make(chan string) //创建一个channel
33     for i := 0; i < 5; i++ {
34         go work(taskch,wg)
35     }
36     urls := []string{"http://www.baidu.com","http://www.zhihu.com","http://www.cnblogs.com/yinzhengjie/p/7201980.html"} //定义需要访问的网站。
37         for _,url := range urls{
38         taskch <- url //往channel发送数据。
39         }
40         close(taskch)
41         wg.Wait() //等待程序结束
42 }
43 
44 
45 
46 #以上代码执行结果如下：
47 2017/07/24 15:23:02 访问的网站是：http://www.baidu.com，网页的大小是:-1
48 2017/07/24 15:23:03 访问的网站是：http://www.cnblogs.com/yinzhengjie/p/7201980.html，网页的大小是:-1
49 2017/07/24 15:23:03 访问的网站是：http://www.zhihu.com，网页的大小是:-1

 

六.channel的引入；

　　Go 语言中的 channel 是实现  goroutine 间无锁通信的关键机制，他使得写多线程并发程序变得简单、灵活、触手可得。channel是Go语言在语言级别提供的goroutine间的通信方式，我们可以使用channel在多个goroutine之间传递消息。channel是进程内的通信方式，因此通过channel传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。

 

1.实现channel的Receive与Sender；

　　初学者可以理解成：channel实际上就是接受和发送数据。channel是类型相关的，一个channel只能传递一种类型的值，这个类型需要在声明channel时指定。有了这些就够了，我们一起来看段代码来感受下channel吧。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import "fmt"
11 
12 
13 
14 func sum(s []int, c chan int) {  //该函数是对切片数组求和，需要传入一个切片数组和一个channel。
15     sum := 0
16     for _,v := range s {
17         sum += v //表示对切片数组进行求和。
18     }
19     c <- sum   //将sum的数据送给名称为c的channel，也就是说将数组中的数字的值传给channel。给channle赋值的时候，其应该在左边。
20 }
21 
22 func main() {
23     Slice_array := []int{1,2,3,4,-9,4,2,0}
24     channel_name := make(chan int)  //用chan定义一个channel对象名称为channel_name，其类型是int。
25     go sum(Slice_array[:len(Slice_array)/2],channel_name)  //在函数上开启协成，注意格式。是在函数前面加个go参数即可。
26     go sum(Slice_array[len(Slice_array)/2:],channel_name)
27     x,y := <-channel_name, <-channel_name  //将channel_name中的数据接收并复制给x和y，当然你也可以定义两个变量名不同的channle，要注意到是取channel的值时，其应该在右边，
28     fmt.Println(x,y,x+y)
29 }
30 
31 
32 
33 #以上代码执行结果如下：
34 -3 10 7

 

2.channel的缓冲大小；

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import "fmt"
11 
12 
13 
14 func main() {
15     ch := make(chan int,5)  /*定义缓冲大小容量为5。下面给channel发送了3个值，如果接受当值超过预定义的5时，就会
16      报错哟！如果你不写的化就会报错:"fatal error: all goroutines are asleep - deadlock!"*/
17     ch <- 100
18     ch <- 200
19     ch <- 300
20     fmt.Println(<-ch)  //第一次取值
21     fmt.Println(<-ch)  //第二次取值
22     fmt.Println(<-ch)  //第三次取值
23 }
24 
25 
26 
27 #以上代码执行结果如下：
28 100
29 200
30 300

 

3.channel的应用；

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import "fmt"
11 
12 func fibonacci(n int,c chan int) { //定义斐波拉契数列函数。
13     x,y := 0,1
14     for i := 0; i < n; i++ { 
15         c <- x
16         x,y = y,x+y
17         if x > 100 {  //表示当循环到两个数字之和大于100时就终止循环。
18             break
19         }
20     }
21     close(c) //关闭channel,如果不关闭就会被锁，出现报错："deadlock!"
22 }
23 
24 func main() {
25     channel_name := make(chan int,15) //定义channel缓冲大小时为15，表示最多存取15个元素。
26     go fibonacci(cap(channel_name),channel_name)
27     for i := range channel_name{  //遍历channel_name
28         fmt.Println(i)
29     }
30 }
31 
32 
33 
34 #以上代码执行结果如下：
35 0
36 1
37 1
38 2
39 3
40 5
41 8
42 13
43 21
44 34
45 55
46 89

 

 4.Channeld的select语法；

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import "fmt"
11 
12 func fibonacci(channel_name,quit chan int)  { //定义两个channle对象channel_name和quit。
13     x,y := 0,1
14     for{
15         select {
16         case channel_name <- x:  //用channel_name接受数据。
17             x,y = y,x+y
18 
19         case <-quit:  //表示当接收到quit的channel时，就执行以下代码。其实就是实现关闭channel的功能。
20             fmt.Println("EXIT")
21             return //函数一退出协程也就跟着退出了
22         }
23     }
24 }
25 
26 func main() {
27     channel_name := make(chan int)
28     quit := make(chan int)
29     go func() {
30         for i := 0; i < 11; i++ {
31             fmt.Println(<-channel_name)  //"<-channel_name"表示读取channel_name中的参数。
32         }
33         quit<- 100 /*当for循环结束后，我们随便给quit的channel传一个值就可以实现退出函数的功能。我们之前需要
34         用close(c)来退出发信号的功能，主动权在"fibonacci"，而我们现在我们用quit来主动退出协程。*/
35     }() //这里加个括号是在调用当前函数。
36     fibonacci(channel_name,quit)  //将channel_name和quit传递给fibonacci函数
37 }
38 
39 
40 
41 #以上代码珍惜结果如下：
42 0
43 1
44 1
45 2
46 3
47 5
48 8
49 13
50 21
51 34
52 55
53 EXIT

 

 5.default语法；

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13 )
14 
15 func main() {
16     tick := time.Tick(1000*time.Millisecond) //也可以这样写：“tick := time.NewTicker(1000*time.Millisecond).C”其中这个点C就是一个channel。
17     boom := time.After(5000*time.Millisecond)
18     for  {
19         select {
20         case <-tick:
21             fmt.Println("滴答。。。")
22         case <-boom:
23             fmt.Println("砰～")
24             return
25         default:
26             fmt.Println("吃一口凉皮")
27             time.Sleep(500*time.Millisecond)
28         }
29     }
30 }
31 
32 
33 
34 #以上代码执行结果如下：
35 吃一口凉皮
36 吃一口凉皮
37 滴答。。。
38 吃一口凉皮
39 吃一口凉皮
40 滴答。。。
41 吃一口凉皮
42 吃一口凉皮
43 滴答。。。
44 吃一口凉皮
45 吃一口凉皮
46 滴答。。。
47 吃一口凉皮
48 吃一口凉皮
49 砰～

 

 6.channel扩展；

A.time.NewTicker用法展示：

　　当我们在写一个监控系统的时候，需要实施监控，但是定义巡检时间的话，需要我们自定义巡检周期性。这个时候我们就可以用到一个叫时间设置器的函数，即：time.NewTicker。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13 )
14 
15 func main() {
16     timer := time.NewTicker(3 * time.Second)  //设置定时器，定义timer的基本单位是三秒。
17     cnt := 0
18     for _ = range timer.C{  //其中timer.C就是一个channel
19         cnt++
20         if cnt > 3 {
21             timer.Stop()  //调用方式
22             return //这里是手动停下来，一般是不会让他停下来，比如在监控的时候，但是有结束条件的时候用return的话是不会报错的
23         }
24         fmt.Println("yinzhengjie")
25     }
26 }
27 
28 
29 
30 #以上代码执行结果如下：
31 
32 yinzhengjie
33 yinzhengjie
34 yinzhengjie

 

B.time.After用法展示：

　　要注意的是，“time.NewTicker”需要调用"Stop"方法才会被执行，而“time.After”调用的姿势也不一样，我们一起来体验一下吧。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "time"
12     "fmt"
13 )
14 
15 func main() {
16     c := time.After(time.Second*3)  //表示让其睡眠3秒钟。
17     <-c   //调用方式
18     fmt.Println("主进程执行完毕")
19 }
20 
21 
22 
23 #以上代码执行结果如下：
24 主进程执行完毕

 

C.channel的深入浅出；

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "net/http"
12     "log"
13     "fmt"
14     "time"
15 )
16 
17 /*
18 1.channel就好像一个传送带，可以源源不断的往里面放数据，只要不close就可以永远发送数据。
19 2.如果channel里面没有数据，接收方会阻塞。
20 3.如果没有人正在等待channel的数据，发送方会阻塞。
21 4.从一个close的channel取数据永远不会阻塞，同时获取的是默认值
22 */
23 
24 
25 func Print_url(url string) {
26     res,err := http.Get(url)
27     if err != nil {
28         log.Fatal("11111",err)
29     }
30     defer res.Body.Close()
31     fmt.Printf("网页的状态返回码是：%v\n",res.Status)
32 
33 }
34 
35 func work(resave chan string) {
36 
37     for  {
38         url,ok := <- resave   //如果channel里面没有数据，接收方会阻塞。用url,ok两个参数来接受channel，可以从channel会返回两个参数。url表示接受的数据。ok接受的信息是channel是否结束。
39         //fmt.Println(url,ok)
40         if !ok { //判断channel是否关闭。
41             break
42         }
43         Print_url(url)
44     }
45 
46     //for i := range resave { //range语法一值在接受数据，而channel可以源源不断的往里面添加数据。从一个close的channel取数据永远不会阻塞，同时获取的是默认值。
47     //    Print_url(i)
48     //}
49 }
50 
51 func main() {
52     make_string := make(chan string)
53     for i := 0;i<3 ;i++  {
54         go work(make_string)
55     }
56     urls := []string{"http://www.baidu.com","http://www.qq.com","http://www.weixin.com"}
57         for _,i := range urls    {
58         make_string <- i //如果没有人正在等待channel的数据，发送方会阻塞。
59         }
60         close(make_string) //channel就好像一个传送带，可以源源不断的往里面放数据，只要不close就可以永远发送数据。
61         time.Sleep(5 * time.Second)
62     }
63 
64 
65 
66 
67 #以上代码输出结果如下：
68 网页的状态返回码是：200 OK
69 网页的状态返回码是：200 OK
70 网页的状态返回码是：200 OK

 

D.waitgroup+channel配合使用；

　　我们可以对C进行优化，在实际生产环境中，我们最好不要用"time.sleep"这个方法来实现主程序等待子程序执行完毕，因为会出现异响不到的bug哟~推荐是用waitgrout来取代这个sleep时间。

 1 package main
 2 
 3 import (
 4     "net/http"
 5     "log"
 6     "fmt"
 7     //"time"
 8     "sync"
 9 )
10 
11 /*
12 1.channel就好像一个传送带，可以源源不断的往里面放数据，只要不close就可以永远发送数据。
13 2.如果channel里面没有数据，接收方会阻塞。
14 3.如果没有人正在等待channel的数据，发送方会阻塞。
15 4.从一个close的channel取数据永远不会阻塞，同时获取的是默认值
16 */
17 
18 
19 func Print_url(url string) {
20     res,err := http.Get(url)
21     if err != nil {
22         log.Fatal("11111",err)
23     }
24     defer res.Body.Close()
25     fmt.Printf("网页的状态返回码是：%v\n",res.Status)
26 
27 }
28 
29 func work(resave chan string,wg *sync.WaitGroup) {
30 
31     for  {
32         url,ok := <- resave   //如果channel里面没有数据，接收方会阻塞。用url,ok两个参数来接受channel，可以从channel会返回两个参数。url表示接受的数据。ok接受的信息是channel是否结束。
33         //fmt.Println(url,ok)
34         if !ok { //判断channel是否关闭。
35             break
36         }
37         Print_url(url)
38     }
39 
40     //for i := range resave { //range语法一值在接受数据，而channel可以源源不断的往里面添加数据。从一个close的channel取数据永远不会阻塞，同时获取的是默认值。
41     //    Print_url(i)
42     //}
43     wg.Done()
44 }
45 
46 func main() {
47     wg := new(sync.WaitGroup)
48     //var num = 3
49     //make_string := make(chan string)
50     //for i := 0;i  {
51     //    go work(make_string,wg)
52     //}
53     //wg.Add(num)
54 
55     make_string := make(chan string)
56     for i := 0;i<3 ;i++  {
57         wg.Add(1)  //启用的协程数和add的进程池保持一致。
58         go work(make_string,wg)
59     }
60 
61     urls := []string{"http://www.baidu.com","http://www.qq.com","http://www.weixin.com"}
62         for _,i := range urls    {
63         make_string <- i //如果没有人正在等待channel的数据，发送方会阻塞。
64         }
65         close(make_string) //channel就好像一个传送带，可以源源不断的往里面放数据，只要不close就可以永远发送数据。
66         //time.Sleep(5 * time.Second)
67         wg.Wait() //等待
68     }
69 
70 
71 
72 #以上代码执行结果如下：
73 网页的状态返回码是：200 OK
74 网页的状态返回码是：200 OK
75 网页的状态返回码是：200 OK

 

七.爬虫进阶之路；

　　在我们想要写出来一个爬虫出来，我们首先得了解几个模块，知道它的用法，这样我们才能写出一个真正的爬虫，接下来跟我一起看看常用的几个模块吧。

1."net/http"模块用法展示；

　　"net/http"模块可用于爬去url的内容。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "net/http"
12     "log"
13     "io"
14     "os"
15 )
16 
17 func main() {
18     url := "http://www.xiaohuar.com"  //定义一个URl，也就是我们要爬的网站。
19     resp,err := http.Get(url) //获取url的内容。
20     if err != nil {
21         log.Fatal(err)
22     }
23     defer resp.Body.Close()  //千万要关闭链接，不然会造成资源泄露。
24     if resp.StatusCode != http.StatusOK{ //如果返回状态出现错误，就抛出错误。
25         log.Fatal(resp.Status)
26     }
27     io.Copy(os.Stdout,resp.Body) //将正常的结果输出到屏幕上，并不会占用内存。
28 }

  1 [root@yinzhengjie tmp]# more http.go 
  2 package main
  3 
  4 import (
  5         "net/http"
  6         "log"
  7         "io"
  8         "os"
  9 )
 10 
 11 func main() {
 12         url := "http://www.xiaohuar.com"  //定义一个URl，也就是我们要爬的网站。
 13         resp,err := http.Get(url)
 14         if err != nil {
 15                 log.Fatal(err)
 16         }
 17         defer resp.Body.Close()  //千万要关闭链接，不然会造成资源泄露。
 18         if resp.StatusCode != http.StatusOK{ //如果返回状态出现错误，就抛出错误。
 19                 log.Fatal(resp.Status)
 20         }
 21         io.Copy(os.Stdout,resp.Body) //将结果输出到屏幕上，并不会占用内存。
 22 }
 23 
 24 [root@yinzhengjie tmp]# 
 25 [root@yinzhengjie tmp]# 
 26 [root@yinzhengjie tmp]# go run http.go 
 27 "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 28 "http://www.w3.org/1999/xhtml">
 29 
 30 "Content-Type" content="text/html; charset=gb2312"/>
 31 "Cache-Control" content="no-transform"/>
 32 "Cache-Control" content="no-siteapp"/>
 33 "alternate" media="only screen and(max-width: 640px)" href="http://m.xiaohuar.com/">
 34