3.其实，总结来看，为什么会死锁？非缓冲信道上如果发生了流入无流出，或者流出无流入，也就导致了死锁。或者这样理解 Go启动的所有goroutine里的非缓冲信道一定要一个线里存数据，一个线里取数据，要成对才行 。所以下面的示例一定死锁:

package main

func main() {
    c, quit := make(chan int), make(chan int)

    go func() {
        c <- 1 //c通道的数据没有被其他goroutine读取走，堵塞当前goroutine
        quit <- 0 //quit始终没有办法写入数据
    }()
    
    <- quit //quit等待数据的写
}

仔细分析的话，是由于：主线等待quit信道的数据流出，quit等待数据写入，而func被c通道堵塞，所有goroutine都在等，所以死锁。
简单来看的话，一共两个线，func线中流入c通道的数据并没有在main线中流出，肯定死锁。

但是，是否果真 所有不成对向信道存取数据的情况都是死锁?

如下是个反例：

package main

func main() {

    c := make(chan int)

    go func() {
        c <- 1
    }()
}

程序正常退出了，很简单，并不是我们那个总结不起作用了，还是因为一个让人很囧的原因，main又没等待其它goroutine，自己先跑完了， 所以没有数据流入c信道，一共执行了一个goroutine, 并且没有发生阻塞，所以没有死锁错误。

那么死锁的解决办法呢？
最简单的，把没取走的数据取走，没放入的数据放入， 因为无缓冲信道不能承载数据，那么就赶紧拿走！
具体来讲，就死锁例子3中的情况，可以这么避免死锁:

package main

func main() {
    c, quit := make(chan int), make(chan int)

    go func() {
        c <- 1 //c通道的数据没有被其他goroutine读取走，堵塞当前goroutine
        quit <- 0 //quit始终没有办法写入数据
    }()
    
    <- c    //取走c的数据
    <- quit //quit等待数据的写
}

另一个解决办法是缓冲信道, 即设置c有一个数据的缓冲大小:

c := make(chan int, 1)

这样的话，c可以缓存一个数据。也就是说，放入一个数据，c并不会挂起当前线, 再放一个才会挂起当前线直到第一个数据被其他goroutine取走, 也就是只阻塞在容量一定的时候，不达容量不阻塞。

无缓冲信道的数据进出顺序我们已经知道，无缓冲信道从不存储数据，流入的数据必须要流出才可以。
观察以下的程序:

package main

import "fmt"

var ch chan int = make(chan int)

func foo(id int) {
    ch <- id
}
func main() {

    //开启5个routine
    for i := 0; i < 5; i++ {
        go foo(i)
    }

    //取出信道中的数据
    for i := 0; i < 5; i++ {
        fmt.Print(<- ch)
    }
}

们开了5个goroutine，然后又依次取数据。其实整个的执行过程细分的话，5个线的数据 依次流过信道ch, main打印之, 而宏观上我们看到的即 无缓冲信道的数据是先到先出，但是 无缓冲信道并不存储数据，只负责数据的流通

缓冲信道

终于到了这个话题了, 其实缓存信道用英文来讲更为达意: buffered channel.

缓冲这个词意思是，缓冲信道不仅可以流通数据，还可以缓存数据。它是有容量的，存入一个数据的话 , 可以先放在信道里，不必阻塞当前线而等待该数据取走。

当缓冲信道达到满的状态的时候，就会表现出阻塞了，因为这时再也不能承载更多的数据了，「你们必须把 数据拿走，才可以流入数据」。

在声明一个信道的时候，我们给make以第二个参数来指明它的容量(默认为0，即无缓冲):

var ch chan int = make(chan int, 2) // 写入2个元素都不会阻塞当前goroutine, 存储个数达到2的时候会阻塞

如下的例子，缓冲信道ch可以无缓冲的流入3个元素:

package main

func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3   
}

如果你再试图流入一个数据的话，信道ch会阻塞main线, 报死锁。
也就是说，缓冲信道会在满容量的时候加锁。

其实，缓冲信道是先进先出的，我们可以把缓冲信道看作为一个线程安全的队列：

package main

import "fmt"

func main() {

    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3

    fmt.Println(<-ch) //1
    fmt.Println(<-ch) //2
    fmt.Println(<-ch) //3
}

信道数据读取和信道关闭你也许发现，上面的代码一个一个地去读取信道简直太费事了，Go语言允许我们使用range来读取信道:

package main

import "fmt"

func main() {

    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3

    for v := range ch {
        fmt.Println(v)
    }
}

如果你执行了上面的代码，会报死锁错误的，原因是range不等到信道关闭是不会结束读取的。也就是如果 缓冲信道干涸了，那么range就会阻塞当前goroutine, 所以死锁咯。

那么，我们试着避免这种情况，比较容易想到的是读到信道为空的时候就结束读取:

package main

import "fmt"

func main() {

    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中存了数据，现在一个一个往外取，信道大小是递减的。

另一个方式是显式地关闭信道:

package main

import "fmt"

func main() {

    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3

    //显式地关闭信道
    close(ch)

    for v := range ch {
        fmt.Println(v)
    }
}

被关闭的信道会禁止数据流入, 是只读的。我们仍然可以从关闭的信道中取出数据，但是不能再写入数据了。

等待多gorountine的方案那好，我们回到最初的一个问题，使用信道堵塞主线，等待开出去的所有goroutine跑完。

这是一个模型，开出很多小goroutine, 它们各自跑各自的，最后跑完了向主线报告。