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
court <- ball

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

buffer没满则,写入\发送 不会阻塞;buffer不空,则读取\接收 不会阻塞。发送和接收不是同步的。但多说一句,其实这种情况不太常用,原因也很简单。因为上下游的消费情况是统一的,如果生产者生产的速度过快,而消费端跟不上的话,即使把它先暂存在缓冲区当中也没什么用,早晚还是会要阻塞的。