Go语言通道之无缓冲通道

一、通道是什么？

其实无论是原子函数还是共享锁都是通过共享内存的方式进行的同步、效率一般不高，而Go语言中则使用了通道，它是一种通过传递信息的方式进行数据同步，通过发送和接收需要共享的资源，在goroutine 之间做同步。可以把通道看作是Goroutine之间的桥梁。

例1：创建一个通道

// 无缓冲的整型通道
unbuffered := make(chan int)
// 有缓冲的字符串通道
buffered := make(chan string, 10)

通道分为有缓冲和无缓冲的通道。

创建一个Channel的关键点：1.使用make创建 2.使用chan来告诉make我要创建的是通道 3.要告诉通道我要建立什么类型的通道。

例2:向通道发送值和接受值

// 有缓冲的字符串通道
buffered := make(chan string, 10)
// 通过通道发送一个字符串
buffered <- "Gopher"
// 从通道接收一个字符串
value := <-buffered

这个例子中创建了一个string类型的Channel，并向通道内传递了一个“Gopher”字符串，这里是通过<-进行传入的，然后通过<-这个方式把值放到value当中。

这里我的理解 <-就好比是一个赋值符号，无论是把值传递到Channel中，还是把Channel中的值传出来，都是将右边的值给左边

二、通道的种类

由上面的例如1，可以看到Channel也是有多种的，分为无缓冲通道和有缓冲通道，下面就简单总结一下两种类型的通道。

1.无缓冲通道

无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。这种类型的通道要求发送goroutine 和接收goroutine 同时准备好，才能完成发送和接收操作。

上面的图很好的解释了通道和Goroutine的关系

1.左右两个goroutine都没有将手放到通道中。

2.左边的Goroutine将手放到了通道中，模拟了将数据放入通道，此时goroutine会被锁住

3.右边的Goroutine也将手放到了通道中，模拟了从通道中取出数据，同样进入了通道也会被锁住

4.两者通过通道执行数据的交换

5.交换完成

6.两者将手从通道中拿出，模拟了被锁住的goroutine被释放

下面这个程序，模拟了两个人打网球，很好的模拟了两个协程间通过channel进行数据交换

package ChannelDemo
import (
　　"fmt"
　　"math/rand"
　　"sync"
　　"time"
)
var wg sync.WaitGroup
func init() {
    rand.Seed(time.Now().UnixNano())
}
func PlayTennis() {
    court := make(chan int)
    wg.Add(2)
    //启动了两个协程，一个纳达尔一个德约科维奇
    go player("纳达尔", court)
    go player("德约科维奇", court)
    //将1放到通道中，模拟开球
    court <- 1
    wg.Wait()
}
func player(name string, court chan int) {
    defer wg.Done()
    for {
        // 将数据从通道中取出
        ball, ok := <-court
        if !ok {
            fmt.Printf("选手 %s 胜利\n", name)
            return
        }
        //获取一个随机值，如果可以整除13，就让一个人没有击中，进而关闭整个通道
        n := rand.Intn(100)
        if n%13 == 0 {
            fmt.Printf("选手 %s 没接到\n", name)
            close(court)
            return
        }
        //如果击中球，就将击球的数量+1，放回通道中
        fmt.Printf("选手 %s 击中 %d\n", name, ball)
        ball++
        court <- ball
    }
}

执行结果（每次会有变化）：

选手纳达尔击中 1
选手德约科维奇击中 2
选手纳达尔击中 3
选手德约科维奇击中 4
选手纳达尔击中 5
选手德约科维奇击中 6
选手纳达尔击中 7
选手德约科维奇击中 8
选手纳达尔没接到
选手德约科维奇胜利

ok 标志是否为false。如果这个值是false，表示通道已经被关闭，游戏结束。

下面这个例子，模拟里一个接力赛，也就是协程之间的传递的另一种形式

package ChannelDemo
import (
    "fmt"
    "sync"
    "time"
)
var runnerWg sync.WaitGroup
func Running() {
    //创建一个“接力棒”，也就是通道
    baton := make(chan int)
    runnerWg.Add(1)
    //创建第一个跑步走
    go Runner(baton)
    //开始跑
    baton <- 1
    runnerWg.Wait()
}
func Runner(baton chan int) {
    var newRunner int
    //选手接过接力棒
    runner := <-baton
    fmt.Printf("第 %d 选手接棒 \n", runner)
    //如果不是第四名选手，那么说明比赛还在继续
    if runner != 4 {
        //创建一名新选手
        newRunner = runner + 1
        fmt.Printf("第 %d 准备接棒 \n", newRunner)
        go Runner(baton)
    }
    //模拟跑步
    time.Sleep(100 * time.Millisecond)
    //如果第四名跑完了，就结束
    if runner == 4 {
        fmt.Printf("第 %d 结束赛跑 \n", runner)
        runnerWg.Done()
        return
    }
    fmt.Printf("第 %d 选手和第 %d 选手交换了接力棒 \n",
        runner,
        newRunner)
    //选手递出接力棒
    baton <- newRunner
}

运行结果：

第 1 名选手接棒
第 2 名选手准备接棒
第 1 名选手将接力棒递给第 2 名选手
第 2 名选手接棒
第 3 名选手准备接棒
第 2 名选手将接力棒递给第 3 名选手
第 3 名选手接棒
第 4 名选手准备接棒
第 3 名选手将接力棒递给第 4 名选手
第 4 名选手接棒
第 4 名选手冲线，比赛结束

三、无缓冲通道小结

我在看例子的过程中，其实遇到的问题在于，我没有理解goroutine是怎么进行交换的，我以为是goroutine有一个集合一样的结构在通道外面等待取数据，这样就存在我刚拿完再那的情况。就像下面这个图显示一样