协程
学习go也有一段时间了，这里讲一下自己对go协程的使用理解。
go很多人都知道，毕竟有个好爹Google，提起go和其它语言最大区别莫过于 goroutine，也就是go的协程，先来一个demo：
package main
func say(s string) {
for i := 0; i < 5; i++ {
println(s)
}
}
func main() {
go say("Hello")
go say("World")
}
go 启动协程的方式就是使用关键字 go，后面一般接一个函数或者类似下面的匿名函数的写法
go func() {
for i := 0; i < 5; i++ {
println(i)
}
}()
当然如果你运行上面第一段代码，你会发现什么结果都没有，what？？？
这至少说明你代码写的没问题，当你使用go启动协程之后,这2个函数就被切换到协程里面执行了，但是这时候主线程结束了，这2个协程还没来得及执行就挂了！
聪明的小伙伴会想到，那我主线程先睡眠1s等一等？Yes, 在main代码块最后一行加入：
time.Sleep(time.Second*1) # 表示睡眠1s
你会发现可以打印出5个Hello 和 5个World，多次运行你会发现Hello 和 World 的顺序不是固定的，这进一步说明了一个问题，那就是多个协程是同时执行的
不过睡眠这种做法肯定是不靠谱的，go 自带一个WaitGroup可以解决这个问题, 代码如下:
package main
import (
"sync"
)
var wg sync.WaitGroup
func say(s string) {
for i := 0; i < 5; i++ {
println(s)
}
wg.Done()
}
func main() {
wg.Add(2)
go say("Hello")
go say("World")
wg.Wait()
}
简单说明一下用法，var 是声明了一个全局变量 wg，类型是sync.WaitGroup，wg.add(2) 是说我有2个goroutine需要执行，
wg.Done 相当于 wg.Add(-1) 意思就是我这个协程执行完了。wg.Wait() 就是告诉主线程要等一下，等他们2个都执行完再退出。
举个例子，你有一个需求是从３个库取不同的数据汇总处理，同步代码的写法就是查３次库，但是这３次查询必须按顺序执行，大部分编程语言的代码执行顺序都是从上到下，假如一个
查询耗时１ｓ，３个查询就是３ｓ，但是使用协程你可以让这３个查询同时进行，也就是１ｓ就可以搞定（前提是数据库跟得上）。还有一个更有实际用途的例子就是用来写爬虫。
不过为了更好的使用协程，你可能还得了解一下管道 Chanel，go 里面的管道是协程之间通信的渠道，上面的例子里面我们是直接打印出来结果，假如现在的需求是把输出结果返回到主线程呢？
package main
import (
"sync"
)
var wg sync.WaitGroup
func say(s string, c chan string) {
for i := 0; i < 5; i++ {
c <- s
}
wg.Done()
}
func main() {
wg.Add(2)
ch := make(chan string) // 实例化一个管道
go say("Hello", ch)
go say("World", ch)
for {
println(<-ch) //循环从管道取数据
}
wg.Wait()
}
简单说明一下，这里就是实例化了一个管道，go启动的协程同时向这个2个管道输出数据，主线程使用了一个for循环从管道里面取数据，其实就是一个生产者和消费者模式，和redis队列有点像
值得一说的是 World 和 Hello 进入管道的顺序是不固定的，可能大家实验的时候发现好像是固定的，那是因为电脑跑的太快了，你把循环数据放大，或者在里面加个睡眠再看看
但是这个程序是有bug的，在程序的运行的最后会输出这样的结果：
fatal error: all goroutines are asleep - deadlock!
报错信息的提示意思是所有的协程都睡眠了，程序监测到死锁！为什么会这样呢？我是这样理解的，go的管道默认是阻塞的(假如你不设置缓存的话)，你那边放一个，我这头才能取一个，
如果你那边放了东西这边没人取，程序就会一直等下去，死锁了，同时，如果那边没人放东西，你这边取也取不到，也会发生死锁！
如何解决这个问题呢？标准的做法是主动关闭管道，或者你知道你应该什么时候关闭管道, 当然你结束程序管道自然也会关掉！针对上面的演示代码，可以这样写：
i := 1
for {
str := <- ch
println(str)
if i >= 10{
close(ch)
break
}
i++
}
因为我们明确知道总共会输出10个单词，所以这里简单做了一个判断，大于10就关闭管道退出for循环，就不会报错了！下面是一个利用select从管道取数据的例子：
package main
import (
"strconv"
"fmt"
"time"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan string)
go pump1(ch1)
go pump2(ch2)
go suck(ch1, ch2)
time.Sleep(time.Duration(time.Second*30))
}
func pump1(ch chan int) {
for i := 0; ; i++ {
ch <- i * 2
time.Sleep(time.Duration(time.Second))
}
}
func pump2(ch chan string) {
for i := 0; ; i++ {
ch <- strconv.Itoa(i+5)
time.Sleep(time.Duration(time.Second))
}
}
func suck(ch1 chan int, ch2 chan string) {
chRate := time.Tick(time.Duration(time.Second*5)) // 定时器
for {
select {
case v := <-ch1:
fmt.Printf("Received on channel 1: %d\n", v)
case v := <-ch2:
fmt.Printf("Received on channel 2: %s\n", v)
case <-chRate:
fmt.Printf("Log log...\n")
}
}
}
输出结果如下：
Received on channel 1: 0
Received on channel 2: 5
Received on channel 2: 6
Received on channel 1: 2
Received on channel 1: 4
Received on channel 2: 7
Received on channel 1: 6
Received on channel 2: 8
Received on channel 2: 9
Received on channel 1: 8
Log log...
Received on channel 2: 10
Received on channel 1: 10
Received on channel 1: 12
Received on channel 2: 11
Received on channel 2: 12
Received on channel 1: 14
这个程序建立了2个管道一个传输int，一个传输string，同时启动了3个协程，前2个协程非常简单，就是每隔1s向管道输出数据，第三个协程是不停的从管道取数据，
和之前的例子不一样的地方是，pump1 和 pump2是2个不同的管道，通过select可以实现在不同管道之间切换，哪个管道有数据就从哪个管道里面取数据，如果都没数据就等着，
还有一个定时器功能可以每隔一段时间向管道输出内容！
最后，值得一说的是，go 自带的web server性能非常强悍，主要就是因为使用了协程，对于每一个web请求，服务器都会新开一个go协程去处理，一个服务器可以轻松同时开启上万个协程。
