概述
进程，线程的概念在操作系统的书上已经有详细的介绍。进程是内存资源管理和cpu调度的执行单元。为了有效利用多核处理器的优势，将进程进一步细分，允许一个进程里存在多个线程，这多个线程还是共享同一片内存空间，但cpu调度的最小单元变成了线程。
那协程又是什么东西，以及与线程的差异性?
协程，可以看作是轻量级的线程。但与线程不同的是，线程的切换是由操作系统控制的，而协程的切换则是由用户控制的。
最早支持协程的程序语言应该是lisp方言scheme里的continuation（续延），续延允许scheme保存任意函数调用的现场，保存起来并重新执行。Lua,C#,python等语言也有自己的协程实现。
Go语言从语言层面上就支持了并发，这与其他语言大不一样，不像以前我们要用Thread库 来新建线程，还要用线程安全的队列库来共享数据。
Go的goroutine
goroutinue，本质上就是协程。但也存在两点不同：
- goroutine可以实现并行，也就是说，多个协程可以在多个处理器上跑。而协程同一时刻只能在一个处理器上跑（把宿主语言想象成单线程就好了）。
- goroutine之间通信是通过channel，而协程通信时通过yield和resume()操作。
以下的程序，我们串行地去执行两次loop函数:
func loop(){
for i:=0;i<10;i++{
fmt.Println(i)
}
}
func main(){
loop()
loop()
}毫无疑问，输出会是这样的:
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9下面我们把一个loop放在一个goroutine里跑，我们可以使用关键字go来定义并启动一个goroutine:
func main() {
go loop() // 启动一个goroutine
loop()
}这次的输出变成了:
0 1 2 3 4 5 6 7 8 9可是为什么只输出了一趟呢？明明我们主线跑了一趟，也开了一个goroutine来跑一趟啊。
原来，在goroutine还没来得及跑loop的时候，主函数已经退出了。
main函数退出地太快了，我们要想办法阻止它过早地退出，一个办法是让main等待一下:
func main() {
go loop()
loop()
time.Sleep(time.Second) // 停顿一秒
}这次确实输出了两趟，目的达到了。
可是采用等待的办法并不好，如果goroutine在结束的时候，告诉下主线说“Hey, 我要跑完了！”就好了， 即所谓阻塞主线的办法，回忆下我们Python里面等待所有线程执行完毕的写法:
for thread in threads:
thread.join()是的，我们也需要一个类似join的东西来阻塞住主线--那就是信道。
Go的channel
信道是什么？
简单说，是goroutine之间互相通讯的东西。在java的世界里，并发主要是靠锁住临界资源（共享内存）来保证同步的。类似我们Unix上的管道（可以在进程间传递消息）， 用来goroutine之间发消息和接收消息。 其实，就是在做goroutine之间的内存共享。
channel可以形象比喻为工厂里的传送带,一头的生产者goroutine往传输带放东西,另一头的消费者goroutinue则从输送带取东西。channel实际上是一个有类型的消息队列,遵循先进先出的特点。
1. channel的操作
ch <- ele 表示：ele被发送给channel ch ；
2. channel的阻塞
channel默认没有缓冲区，也就是说，通信是阻塞的。send操作必须等到有消费者accept才算完成。
无缓冲的信道在取消息和存消息的时候都会挂起当前的 goroutine，除非另一端已经准备好。
使用make来建立一个信道:
var message chan int = make(chan int)
// 或
message := make(chan int)那如何向信道存消息和取消息呢？举例如下：
func main() {
var messages chan string = make(chan string)
go func(message string) {
messages <- message // 存消息
}("Ping!")
fmt.Println(<-messages) // 取消息
}那既然信道可以阻塞当前的goroutine, 那么回到上一部分「goroutine」所遇到的问题「如何让goroutine告诉主线我执行完毕了」 的问题来, 使用一个信道来告诉主线即可:
var complete chan int = make(chan int)
func loop() {
for i := 0; i < 10; i++ {
fmt.Printf("%d ", i)
}
complete <- 0 // 执行完毕了，发个消息
}
func main() {
go loop()
<- complete // 直到线程跑完, 取到消息. main在此阻塞住
}如果不用信道来阻塞主线的话，主线就会过早跑完，loop线都没有机会执行、、、
package main
import "fmt"
func main() {
ch1 := make(chan int)
go pump(ch1) // pump hangs
fmt.Println(<-ch1) // prints only 0
}
func pump(ch chan int) {
for i:= 0; ; i++ {
ch <- i
}
} 面代码pump()里的channel在接受到第一个元素后就被阻塞了，直到主goroutinue拿走了数据。最终channel阻塞在接受第二个元素，程序只打印 0
其实，无缓冲的信道永远不会存储数据，只负责数据的流通，为什么这么讲呢？
从无缓冲信道取数据，必须要有数据流进来才可以，否则当前线阻塞
数据流入无缓冲信道, 如果没有其他goroutine来拿走这个数据，那么当前线阻塞
所以，你可以测试下，无论如何，我们测试到的无缓冲信道的大小都是0 (len(channel))
带有buff的channel：
ch := make(chan int, 3)没有buff的channel只能容纳一个元素，而带有buff的channel则可以非阻塞容纳N个元素。发送数据到buffed channel不会被阻塞，除非channel已满；同样的，从buffed channel取数据也不会被阻塞，除非channel空了。这有点像java的ConcurrentLinkedQueue。
Go的deadlock
一个死锁的例子:
func main() {
ch := make(chan int)
<- ch // 阻塞main goroutine, 信道ch被锁
}执行这个程序你会看到Go报这样的错误:
fatal error: all goroutines are asleep - deadlock!何谓死锁? 操作系统有讲过的，所有的线程或进程都在等待资源的释放。如上的程序中, 只有一个goroutine, 所以当你向里面加数据或者存数据的话，都会锁死信道， 并且阻塞当前 goroutine, 也就是所有的goroutine(其实就main线一个)都在等待信道的开放(没人拿走数据信道是不会开放的)，也就是死锁咯。
其实，总结来看，为什么会死锁？非缓冲信道上如果发生了流入无流出，或者流出无流入，也就导致了死锁。或者这样理解 Go启动的所有goroutine里的非缓冲信道一定要一个线里存数据，一个线里取数据，要成对才行
那么死锁的解决办法呢？
最简单的，把没取走的数据取走，没放入的数据放入， 因为无缓冲信道不能承载数据，那么就赶紧拿走！
Go的deadlock 信道数据
你也许发现，上面的代码一个一个地去读取信道简直太费事了，Go语言允许我们使用range来读取信道:
func main() {
ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
for v := range ch {
fmt.Println(v)
}
}如果你执行了上面的代码，会报死锁错误的，原因是range不等到信道关闭是不会结束读取的。也就是如果 缓冲信道干涸了，那么range就会阻塞当前goroutine, 所以死锁咯。
那么，我们试着避免这种情况，比较容易想到的是读到信道为空的时候就结束读取:
ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
for v := range ch {
fmt.Println(v)
if len(ch) <= 0 { // 如果现有数据量为0，跳出循环
break
}
}以上的方法是可以正常输出的，但是注意检查信道大小的方法不能在信道存取都在发生的时候用于取出所有数据，这个例子 是因为我们只在ch中存了数据，现在一个一个往外取，信道大小是递减的。
另一个方式是显式地关闭信道:
ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
// 显式地关闭信道
close(ch)
for v := range ch {
fmt.Println(v)
}End