Go语言的goroutines,信道和死锁
goroutine
goroutine有点类似线程，但是更轻。
使用关键字go来定义并启动一个goroutine：
func main(){
go loop()
loop()
time.Sleep(time.Second) // main函数太快，为了等待一下goroutine，停顿一秒
}
如果goroutine在结束的时候，能跟主线程能通信，那就需要信道。
信道
简单来说，channel信道是goroutine之间相互通信的东西。用来goroutine之间发消息和接收消息。其实，就是在做goroutine之间的内存共享。
是用make来建立一个信道：
var channel chan int = make(chan int)
// 或者直接声明
channel := make(chan int)
向信道存消息和取消息，一个例子说明：
func main(){
var message chan string = make(chan string)
go func(message string){
message <- message // 存消息
}("Ping!")
fmt.Println(<-message) // 取消息
}
信道的存消息和取消息都是阻塞的，也就是说，无缓冲的信道在取消息和存消息的时候都会挂起当前的goroutine，除非另一端已经准备好。
有了这个阻塞的机制，来实现让goroutine告诉主线程：我执行完了。下面的demo很简单就做到了。
var complete chan int = make(chan int)
func loop(){
for i:=0;i<10;i++{
fmt.Printf("%d",i)
}
completee <- 0 // 执行完毕，发个消息
}
func main(){
go loop()
<- complete // loop()线程跑完，收到消息，main接着跑
}
其实，无缓冲的信道永远不会存储数据，只会负责数据的流通。
- 从无缓冲信道取数据，必须要有数据流进来才可以，否则当前线程阻塞
- 数据流入无缓冲信道，如果没有其他goroutine取走数据，那么当前线程阻塞
如果信道正有数据，那还要加入数据，或者信道没有数据，硬要取数据，就会引起死锁。
死锁
一个死锁的简单例子：
func main(){
ch := make(chan int)
<- ch // 没有往ch信道存放数据，就开始取数据，就直接阻塞main goroutine，信道ch被锁
}
其实简单理解就是，一个goroutine，向里面加数据或者存数据，都会锁死信道，并且阻塞当前goroutine，也就是死锁。
死锁的解决办法也很简单，没取走的数据赶紧取走，没放入的数据一定要放入，无缓冲信道不能承载数据。
另外一个解决办法就是缓冲信道，即设置channel有一个数据的缓冲大小：
c := make(chan int,1)
这个也很好理解，c可以缓存一个数据，放入一个，不会阻塞，再放入一个，阻塞，被其他goroutine取走一个，又不阻塞。
也就是说，只阻塞在容量一定的时候，不达容量就不阻塞。
非常类似Pyhton里面的Queue的概念。
无缓冲信道的数据进出顺序
一句话说清楚：无缓冲信道的数据是先到先出。
缓冲信道
缓冲信道在流入的数据数目超过容量的时候，就会死锁。
可以简单把缓冲信道看成是一个线程安全的队列。
信道数据读取和信道关闭
取信道消息可以用range进行遍历：
for v := range ch{ // ch := make(chan int,3)
fmt.Println(v)
if len(ch) <= 0{
break // 为了避免信道没消息了，还去取造成死锁。
}
}
等待多goroutine的方案
使用信道阻塞主线，其他goroutine跑完回到主线。
其实无缓冲信道和缓冲信道都能实现这个需求，伪代码如下：
package main
import "fmt"
var quit chan int
func foo(id int){
fmt.Println(id)
quit <- 0
}
func main(){
count := 1000
quit = make(chan int)
for i:=0;i<count;i++{
go foo(i)
}
for i:=0;i<count;i++{
<- quit
}
}
// 无缓冲的信道是一批数据一个一个的流进流出，处理是乱序的
package main
import "fmt"
func foo(id int){
fmt.Println(id)
}
func main(){
count := 1000
quit := make(chan int,1000)
for i:=0;i<count;i++{
foo(i)
quit <- i
}
for i:=0;i<count;i++{
<- quit
}
}
// 有缓冲的信道是数据一个一个进行处理，处理是顺序的