本文摘自网络，作者，侵删。

golang 无缓存channel和有缓存channel

无缓存通道

var ch = make(chan int)  // 创建一个int类型的channel
cap(ch)                  // ch的容量是0

发送/存入

ch <- 1  // 存入一个int类型的值

接收/取出

x := <-ch  // 取出ch中的值，并赋值给x

关闭

close(ch) // 关闭发送方channel，对接收发channel关闭操作会panic
val, ok := <-ch // ok 可用于判断通道是否关闭。

  

| 操作  |  nil  |       closed channel       |
| :---: | :---: | :------------------------: |
| close | panic |           panic            |
| 存入  | 阻塞  |           panic            |
| 取出  | 阻塞  | 返回对应类型零值和关闭信号 |

了解了channel的基本语法，我们看一个例子

```go
func main() {
    ch := make(chan int) // 创建一个无缓存channel
    ch <- 233
    fmt.Println(<-ch)
}

上面的代码可以成功执行吗？答案是否定的。会出现死锁。这是因为 ch是一个无缓存的channel，当我们向它存入值的时候，会阻塞所在goroutine，这里当然是main.main的goroutine，后面的语句根本不会执行到。那么我们应该怎么修改呢，继续看代码：

func main() {
    ch := make(chan int)
    go func(chan int) { ch <- 233 }(ch)
    fmt.Println(<-ch)
}

这里我们在main.main 主goroutine 中新建了一个goroutine，这样阻塞的就是这个goroutine了，不影响main.main。当主协程执行到<-ch的时候，取出值，完成一次同步通信。

一句话总结：无缓存的channel只有在receiver准备好后send才被执行，也就是说receiver的goroutine 和sender的goroutine 必须成对出现

之前看到一个打网球的模拟，很有趣，可以加深一下理解，我们看一下

package main

import(
    "math/rand"
    "sync"
    "time"
    "fmt"
)

// wg用来等待程序结束
var wg sync.WaitGroup

func init() {
    rand.Seed(time.Now().UnixNano())
}

// main是所有Go程序的入口
func main() {
    // 创建一个无缓冲的通道
    court := make(chan int)

    // 计数加2，表示要等待两个goroutine
    wg.Add(2)

    // 启动两个选手
    go player("Nick", court)
    go player("Jack", court)

    // 发球
    court <- 1

    // 等待游戏结束
    wg.Wait()
}

// player 模拟一个选手在打网球
func player(name string, court chan int) {
    // 在函数退出时调用Done来通知main函数工作已经完成
    defer wg.Done()

    for{
        // 等待球被击打过来
        ball, ok := <-court
        if !ok {
            // 如果通道被关闭，我们就赢了
            fmt.Printf("Player %s Won\n", name)
            return
        }

        // 选随机数，然后用这个数来判断我们是否丢球
        n := rand.Intn(100)
        if n%5 == 0 {
            fmt.Printf("Player %s Missed\n", name)

            // 关闭通道，表示我们输了
            close(court)
            return
        }

        // 显示击球数，并将击球数加1
        fmt.Printf("Player %s Hit %d\n", name, ball)
        ball++

        // 将球打向对手
        court <- ball
    }
}

E:\go\src\learngolang\00test>go run main.go
Player Jack Hit 1
Player Nick Hit 2
Player Jack Hit 3
Player Nick Hit 4
Player Jack Hit 5
Player Nick Hit 6
Player Jack Hit 7
Player Nick Hit 8
Player Jack Hit 9
Player Nick Missed
Player Jack Won

上面的go函数为什么能交替执行呢？首先，我们有main主协程g0，里面创建了两个goroutine，g1，g2，然后，主协程g0向无缓存channel中发送数据，g0阻塞，这时，g1、g2中某一个，如g2，先进入通道的接收队列，则通道获得一次同步，g0取消阻塞。在player函数中court <- ball 这句代码继续向通道发送数据，g2阻塞，这时通道中g1等待接收，g1开始执行，通道接收操作之后，g2取消阻塞，for循环继续等待接收，阻塞，g1最后向通道发送数据，g1阻塞；g2接收数据....直到goroutine结束运行。

WaitGroup是用来让g0等待g1、g2执行的。因为当程序执行到一条go语句时，Go语言的运行时系统，会试图从某个存放空闲的G队列中获取一个G（也就是goroutine），没有则创建一个新的G。Go语言运行时系统会用这个G去包装当前的那个go函数（或者说该函数中的那些代码），然后再把这个G追加到某个存放可运行的G的队列中。这类队列中的G总是会按照先入先出的顺序，很快地由运行时系统内部的调度器安排运行。虽然这会很快，但是由于上面所说的那些准备工作还是不可避免的，所以耗时还是存在的。因此，go函数的执行时间总是会明显滞后于它所属的go语句的执行时间。不然，主goroutine代码执行完关闭，其创建的其他goroutine还没来得及执行也就跟着关闭了。

有缓存channel

var ch = make(chan int, 10) //创建一个有缓存的channel，容量是10，即可以传入10个int类型的值

发送
接收

关闭

func main() {
  ch := make(chan int, 10)
  for i := 0; i < 5; i++ {
      ch <- i + 1            // 向channel中传入5 个值
  }
  fmt.Println(len(ch))        // 5      // channel长度为5
  close(ch)                   // 关闭channel
  fmt.Println("--------------")

  for x := range ch {         // range的截止条件是channel关闭，即关闭前存入多少个值，range的范围是多少，如果range的对象没有关闭，则最终阻塞，引起panic
      fmt.Println(x)          // 接收一个，channel的有效值少一个
  }
  fmt.Println("--------------")
  fmt.Println(len(ch))        // 0       // channel 长度为0
  fmt.Println(cap(ch))        // 10      // channel容量为10
}

操作	nil	满	空	closed channel
close	panic	关闭	关闭	panic
存入	阻塞	阻塞	成功发送	panic
取出	阻塞	成功接收	阻塞	空：返回类型零值、false<br />非空：返回相应值、true