当前位置：首页 > news >正文

Go语言并发编程-Channel通信_2

news 文章来源：https://blog.csdn.net/weixin_51568389/article/details/140535203 2024/11/20 4:57:52

Channel通信

Channel概述

不要通过共享内存的方式进行通信，而是应该通过通信的方式共享内存

这是Go语言最核心的设计模式之一。

在很多主流的编程语言中，多个线程传递数据的方式一般都是共享内存，而Go语言中多Goroutine通信的主要方案是Channel。Go语言也可以使用共享内存的方式支持Goroutine通信。

Go语言实现了CSP通信模式，CSP是Communicating Sequential Processes的缩写，通信顺序进程。Goroutine和Channel分别对应CSP中的实体和传递信息的媒介。CSP是Tony Hoare于1977年提出。

Channel提供可接收和发送特定类型值的用于并发函数(Goroutine)通信的数据类型，是满足FIFO（先进先出）原则的队列类型，先进先出不仅体现在数据类型上，也体现在操作上：

channel类型的元素是先进先出的，先发送到channel的value会先被receive
先向Channel发送数据的Goroutine会先执行
先从Channel接收数据的Goroutine会先执行

如图：

Channel操作语法

一个关键字
- chan
- chan <-
- <- chan
两个函数
- make
- close
一个语句
- 发送语句 ch <- expression
一个操作符
- 接收操作符 <- ch

Channel类型

channel是Go语言中的数据类型，类型声明如下：

 ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .

其中：

chan channel类型关键字
<- 操作符，用于Channel收发，定义Channel类型时，用于表示Channel的方向：
- 默认是双向，可收可发。还可以定义为定向的，仅收仅发。
- chan<- 仅发送Channel
- <-chan 仅接收Channel
ElementType Channel中元素类型

可见，Channel类型是用于接收或发送特定类型元素的Go数据类型。

示例：

 chan intchan struct{}chan<- int<-chan int

初始化Channel值

内建函数make()可用于初始化Channel值。支持两个参数：

 make(ChannelType, Capacity)

其中：

ChannelType是channel类型
Capacity是缓冲容量。可以省略或为0，表示无缓冲Channel

channel是引用类型，类似于map和slice。

示例：

 ch := make(chan int)var ch = make(chan int)ch := make(chan int, 10)ch := make(<-chan int)ch := make(chan<- int, 10)

未使用make()初始化的channel为nil。nil channel不能执行收发通信操作，例如：

 var ch chan int

ch就是nil channel。

Send语句和接收操作符

Send语句用于向Channel发送值
接收操作符用于从Channel中接收值

Send语句语法：

 SendStmt = Channel "<-" Expression .Channel  = Expression .

 ch <- Expressionch <- 42ch <- f()

接收操作符语法：

 <-chv1 := <-ch // 声明v = <-ch // 赋值f(<-ch) // 函数调用<-strobe // 等待接收

关闭channel

内置函数close()用于关闭channel。

关闭Channel的意思是记录该Channel不能再被发送任何元素了，而不是销毁该Channel的意思。也就意味着关闭的Channel是可以继续接收值的。因此：

向已关闭的Channel发送回引发runtime panic
关闭nil Channel会引发runtime panic
不能关闭仅接收Channel
不能关闭已经关闭的Channel，否则会引发runtime panic

当从已关闭的Channel接收时：

可以接收关闭前发送的全部值
若没有已发送的值会返回类型的零值，不会被阻塞

使用接收操作符的多值返回结构，可以判断Channel是否已经关闭：

var x, ok = <-ch
x, ok := <-ch

ok为true，channel未关闭
ok为false，channel已关闭

for range channel

for语句的range子句可以持续地从Channel中接收元素，语法如下：

for e := range ch {// e是ch中元素值
}

持续接收操作与接收操作<-行为一致：

若ch为nil channel会阻塞
若ch没有已发送元素会阻塞

for会持续执行到channel被关闭，关闭后，若channel中存在已发送元素，for会全部读取完毕。

示例：

func ChannelFor() {// 一，初始化部分数据ch := make(chan int) // 无缓冲的channelwg := sync.WaitGroup{}// 二，持续发送wg.Add(1)go func() {defer wg.Done()for i := 0; i < 5; i++ {// random send valuech <- rand.Intn(10)}// 关闭close(ch)}()// 三，持续接收，for rangewg.Add(1)go func() {defer wg.Done()// 持续接收for e := range ch {println("received from ch, element is ", e)}}()wg.Wait()
}

缓冲与无冲 channel

Channel区别于是否存在缓冲区，分为：

缓冲Channel，make(chan T, cap)，cap是大于0的值。
无缓冲Channel, make(chan T), make(chan T, 0)

无缓冲channel

也称为同步Channel，只有当发送方和接收方都准备就绪时，通信才会成功。

同步操作示例：

func ChannelSync() {// 初始化数据ch := make(chan int)wg := sync.WaitGroup{}// 间隔发送wg.Add(1)go func() {defer wg.Done()for i := 0; i < 5; i++ {ch <- iprintln("Send ", i, ".\tNow:", time.Now().Format("15:04:05.999999999"))// 间隔时间time.Sleep(1 * time.Second)}close(ch)}()// 间隔接收wg.Add(1)go func() {defer wg.Done()for v := range ch {println("Received ", v, ".\tNow:", time.Now().Format("15:04:05.999999999"))// 间隔时间，注意与send的间隔时间不同time.Sleep(3 * time.Second)}}()wg.Wait()
}

代码中，采用同步channel，使用两个goroutine完成发送和接收。每次发送和接收的时间间隔不同。我们分别打印发送和接收的值和时间。注意结果：

发送和接收时间一致
间隔以长的为准，可见发送和接收操作为同步操作

同步Channel适合在gotoutine间做同步信号！

缓冲Channel

缓冲Channel也称为异步Channel，接收和发送方不用等待双方就绪即可成功。缓冲Channel会存在一个容量为cap的缓冲空间。当使用缓冲Channel通信时，接收和发送操作是在操作Channel的Buffer：

接收时，从缓冲中接收元素，只要缓冲不为空，不会阻塞。反之，缓冲为空，会阻塞，goroutine挂起
发送时，向缓冲中发送元素，只要缓冲未满，不会阻塞。反之，缓冲满了，会阻塞，goroutine挂起

是典型的队列操作。

缓冲channel操作示例：

func ChannelASync() {// 初始化数据ch := make(chan int, 5)wg := sync.WaitGroup{}// 间隔发送wg.Add(1)go func() {defer wg.Done()for i := 0; i < 5; i++ {ch <- iprintln("Send ", i, ".\tNow:", time.Now().Format("15:04:05.999999999"))// 间隔时间time.Sleep(1 * time.Second)}}()// 间隔接收wg.Add(1)go func() {defer wg.Done()for v := range ch {println("Received ", v, ".\tNow:", time.Now().Format("15:04:05.999999999"))// 间隔时间，注意与send的间隔时间不同time.Sleep(3 * time.Second)}}()wg.Wait()
}

代码中，与同步channel一致，只是采用了容量为5的缓冲channel，使用两个goroutine完成发送和接收。每次发送和接收的时间间隔不同。我们分别打印发送和接收的值和时间。注意结果：

发送和接收时间不同
发送和接收操作不会阻塞，可见发送和接收操作为异步操作

缓冲channel非常适合做goroutine的数据通信了。

长度和容量，len()和cap()

内置函数 len() 和 cap() 可以分别获取：

len()长度，缓冲中元素个数。
cap()容量，缓冲的总大小。cap()返回0，意味着是无缓冲通道

单向Channel

单向Channel，指的是仅支持接收或仅支持发送操作的Channel。语法上：

chan<- T 仅发送Channel
<-chan T 仅接收Channel

单向Channel的意义在于约束Channel的使用方式。

仅使用单向Channel通常没有实际意义，单向Channel最典型的使用方式是：

使用单向通道约束双向通道的操作。

语法上来说，就是我们会将双向Channel转换为单向Channel来使用。典型使用在函数参数或返回值类型中。

示例代码：

func ChannelDirectional() {// 初始化数据ch := make(chan int)wg := &sync.WaitGroup{}// send and receivewg.Add(2)go setElement(ch, 42, wg)go getElement(ch, wg)wg.Wait()
}// only receive channel
func getElement(ch <-chan int, wg *sync.WaitGroup) {defer wg.Done()println("received from ch, element is ", <-ch)
}// only send channel
func setElement(ch chan<- int, v int, wg *sync.WaitGroup) {defer wg.Done()ch <- vprintln("send to ch, element is ", v)
}

函数getElement和setElement，分别使用了单向的接收和发送channel，在语义上表示只能接收和只能发送操作，同时程序上限定了操作。

典型的单向Channel的标准库例子：

// signal.Notify()
func Notify(c chan<- os.Signal, sig ...os.Signal)// time.After
func After(d Duration) <-chan Time

以上两个示例分别展示了单向Channel作为函数参数和函数返回值的语法。

Channel结构

Channel定义结构

Channel的结构定义为 runtime.hchan：

// GOROOT/src/runtime/chan.go
type hchan struct {qcount   uint           // 元素个数。len()dataqsiz uint           // 缓冲队列的长度。cap()buf      unsafe.Pointer // 缓冲队列指针，无缓冲队列为nilelemsize uint16 // 元素大小closed   uint32elemtype *_type // 元素类型sendx    uint   // send indexrecvx    uint   // receive indexrecvq    waitq  // list of recv waiterssendq    waitq  // list of send waiters// lock protects all fields in hchan, as well as several// fields in sudogs blocked on this channel.//// Do not change another G's status while holding this lock// (in particular, do not ready a G), as this can deadlock// with stack shrinking.lock mutex
}

其中：

存储空间分为channel和channel.buf两块
channel上记录channel的属性，长度、容量、元素类型、元素大小，接收发送索引、接收发送等待队列
channel.buf为elemtype类型的array
若为无缓冲channel，不分配channel.buf空间
make()初始化的核心操作就是分配内存空间

缓冲数组

缓冲为数组结构，channel记录发送和接收元素的索引:

 sendx    uint   // 发送索引recvx    uint   // 接收索引

缓冲数组是循环使用的，也就是若数组的最后一个元素存储了元素，那么下一次会尝试存储在第一个元素位置。

Channel与Goroutine的关系

Channel记录两个属性，由于记录等待接收和发送的goroutine队列：

recvq    waitq  // 等待接收goroutine队列
sendq    waitq  // 等待发送goroutine队列

当基于某channel的接收或发送的goroutine无法理解执行时，也就是需要阻塞时，会被记录到Channel的等待队列中。当channel可以完成相应的接收或发送操作时，从等待队列中唤醒goroutine进行操作。

其中等待队列是 runtime.waitq 类型，是一个双向链表结构，具体的某个链表节点存在两个指针，指向前后节点：

// GOROOT/src/runtime/chan.go
type waitq struct {first *sudoglast  *sudog
}

其中 *sudog 可以理解为一个挂起的goroutine。

初始化channel流程

make()初始化channel时，会根据是否存在缓冲，选择：

存在缓冲，为channel和buffer分别分配内存，同时channel.buf指向buffer地址
不存在缓冲，仅为channel分配内存，channel.buf为nil。
初始化channel中其他属性

向channel发送流程

语句 ch <- element 向channel发送元素时，大体的执行流程如下：

直接发送：当channel存在等待接受者时，channel.recvq，直接将元素拷贝给等待接受者，并唤醒等待接受者goroutine将其放在M的runnext位置，下次调度立即执行
直接写缓冲区，当缓冲区存在空间时，将发送元素直接写入缓冲区，调整channel.sendx的位置
阻塞发送，当缓冲区已满或无缓冲区时，发送goroutine进入channel.sendq队列，转为阻塞状态，等待其他goroutine从channel中接收元素，进而唤醒发送goroutine

从channel接收流程

操作符 <- ch 从channel中接收元素，大体流程如下：

当存在等待发送者时，channel.sendq
- 若无缓冲区，直接将元素从发送者拷贝到接受者，并唤醒发送者gorutine，进入runnext下次调度执行
- 若存在缓冲区，此时缓冲区是满的，从缓冲区获取元素，并将等待发送者发送元素拷贝到缓冲区，唤醒发送者goroutine。调整channel的recvx和sendx索引位置
当缓冲区有元素时（无等待发送者），直接从缓冲区读取元素
如果缓冲区不存在或缓冲区没有元素时，接收者goroutine进入阻塞状态，进入channel.recvq接受者队列，等待发送者发送数据唤醒。

关闭channel流程

close(ch)关闭channel，主要工作是：

取消channel关联的sendq和recvq队列
调度阻塞在sendq和recvq中的goroutine

select 语句

select 语句能够从多个可读或者可写的Channel中选择一个继续执行，若没有Channel发生读写操作，select 会一直阻塞当前Goroutine。

select语法

SelectStmt = "select" "{" { CommClause } "}" .
CommClause = CommCase ":" StatementList .
CommCase   = "case" ( SendStmt | RecvStmt ) | "default" .
RecvStmt   = [ ExpressionList "=" | IdentifierList ":=" ] RecvExpr .
RecvExpr   = Expression .

语法结构与 switch 类似，但case都要涉及channel操作，示例：

func SelectStmt() {// 声明需要的变量var a [4]intvar c1, c2, c3, c4 = make(chan int), make(chan int), make(chan int), make(chan int)var i1, i2 int// 用于操作channel的goroutinego func() {c1 <- 10}()go func() {<-c2}()go func() {close(c3)}()go func() {c4 <- 40}()// 用于select的goroutinego func() {select {case i1 = <-c1:println("received ", i1, " from c1")case c2 <- i2:println("sent ", i2, " to c2")case i3, ok := <-c3:if ok {println("received ", i3, " from c3")} else {println("c3 is closed")}case a[f()] = <-c4:println("received ", a[f()], " from c4")default:println("no communication")}}()// 简单sleep测试time.Sleep(100 * time.Millisecond)
}func f() int {print("f() was run")return 2
}

测试：

func TestSelectStmt(t *testing.T) {for i := 0; i < 10; i++ {println(i, ":")SelectStmt()}
}

执行流程

select语句的执行分为几个步骤：

对于全部的 case，receive操作的channel操作数、send语句的channel和右表达式在进入select语句时只会基于源码顺序计算一次。计算结果是一组要从中接收或者发送到的channel，以及要发送的相应值。RecvStmt的左侧带有短变量声明或赋值的表达式尚未计算。
如果一个或多个通信可以继续，通过伪随机数选择其中一个继续执行。否则，如果存在default case，选择该case。如果没有default case，select 语句会阻塞直到至少一个通信操作可以继续。
除非选择了default case，那么相应的通信操作会被执行。
如果选择的case是带有短变量声明或赋值的RecvStmt，左侧表达式会被计算，并分配接收的值（或多个值）。
执行所选择的case的语句列表。

for + select

select 匹配到可操作的case或者是defaultcase后，就执行完毕了。实操时，我们通常需要持续监听某些channel的操作，因此典型的select使用会配合for完成。

例如：持续从某个ch内获取数据

func SelectFor() {ch := make(chan int)// send to channelgo func() {for {// 模拟演示数据来自于随机数// 实操时，数据可以来自各种I/O，例如网络、缓存、数据库等ch <- rand.Intn(100)time.Sleep(200 * time.Millisecond)}}()// select receive from channelgo func() {for {select {case v := <-ch:println("received value: ", v)}}}()time.Sleep(3 * time.Second)
}

阻塞select

以下典型的情况会直接导致阻塞goroutine：

不存在任何case的
case监听都是nil channel

示例：

func SelectBlock() {// 空select阻塞println("before select")select {}println("after select")// nil select阻塞var ch chan intgo func() {ch <- 1024}()println("before select")select {case <-ch:case ch <- 42:}println("after select")
}

go test 测试时，会一直阻塞。若上面的代码出现在常规执行流程中，会导致 deadlock。

nil channel的case

nil channel 不能读写，因此通过将channel设置为nil，可以控制某个case不再被执行。

例如，3秒后，不再接受ch的数据：

func SelectNilChannel() {ch := make(chan int)// 写channelgo func() {// 随机写入intrand.Seed(time.Now().Unix())for {ch <- rand.Intn(10)time.Sleep(400 * time.Millisecond)}}()// 读channelgo func() {sum := 0t := time.After(3 * time.Second)for {select {case v := <-ch:println("received value: ", v)sum += vcase <-t:// 将channel设置为nil，不再读写ch = nilprintln("ch was set nil, sum is ", sum)}}}()// sleep 5 秒time.Sleep(5 * time.Second)
}

带有default的select，非阻塞收发

当select语句存在default case时：

若没有可操作的channel，会执行default case
若有可操作的channel，会执行对应的case

这样select语句不会进入block状态，称之为非阻塞（non-block）的收发（channel 的接收和发送）。

示例：多人猜数字游戏，我们在乎是否有人猜中数字：

func SelectNonBlock() {// 初始化数据counter := 10 // 参与人数max := 20     // [0, 19] // 最大范围rand.Seed(time.Now().UnixMilli())answer := rand.Intn(max) // 随机答案println("The answer is ", answer)println("------------------------------")// 正确答案channelbingoCh := make(chan int, counter)// wgwg := sync.WaitGroup{}wg.Add(counter)for i := 0; i < counter; i++ {// 每个goroutine代表一个猜数字的人go func() {defer wg.Done()result := rand.Intn(max)println("someone guess ", result)// 答案争取，写入channelif result == answer {bingoCh <- result}}()}wg.Wait()println("------------------------------")// 是否有人发送了正确结果// 可以是0或多个人// 核心问题是是否有人猜中，而不是几个人select {case result := <-bingoCh:println("some one hint the answer ", result)default:println("no one hint the answer")}
}

特别的情况是存在两个case，其中一个是default，另一个是channel case，那么go的优化器会优化内部这个select。内部会以if结构完成处理。因为这种情况，不用考虑随机性的问题。类似于：

select {case result := <-bingoCh:println("some one hint the answer ", result)default:// 非阻塞的保证，存在default caseprintln("no one hint the answer")
}// 优化伪代码
if selectnbrecv(bingoCh) {println("some one hint the answer ", result)
} else {println("no one hint the answer")
}

Race模式

Race模式，典型的并发执行模式之一，多路同时操作资源，哪路先操作成功，优先使用，同时放弃其他路的等待。简而言之，从多个操作中选择一个最快的。核心工作：

选择最快的
停止其他未完成的

示例代码，示例从多个查询器同时读取数据，使用最先反返回结果的，其他查询器结束：

func SelectRace() {// 一，初始化数据// 模拟查询结果，需要与具体的querier建立联系type Rows struct {// 数据字段// 索引标识Index int}// 模拟的querier数量const QuerierNum = 8// 用于通信的channel，数据，停止信号ch := make(chan Rows, 1)stopChs := [QuerierNum]chan struct{}{}for i := range stopChs {stopChs[i] = make(chan struct{})}// wg,randwg := sync.WaitGroup{}rand.Seed(time.Now().UnixMilli())// 二，模拟querier查询，每个查询持续不同的时间wg.Add(QuerierNum)for i := 0; i < QuerierNum; i++ {// 每一个 queriergo func(i int) {defer wg.Done()// 模拟执行时间randD := rand.Intn(1000)println("querier ", i, " start fetch data, need duration is ", randD, " ms.")// 查询结果的channelchRst := make(chan Rows, 1)// 执行查询工作go func() {// 模拟时长time.Sleep(time.Duration(randD) * time.Millisecond)chRst <- Rows{Index: i,}}()// 监听查询结果和停止信号channelselect {// 查询结果case rows := <-chRst:println("querier ", i, " get result.")// 保证没有其他结果写入，才写入结果if len(ch) == 0 {ch <- rows}// stop信号case <-stopChs[i]:println("querier ", i, " is stopping.")return}}(i)}// 三，等待第一个查询结果的反馈wg.Add(1)go func() {defer wg.Done()// 等待ch中传递的结果select {// 等待第一个查询结果case rows := <-ch:println("get first result from ", rows.Index, ". stop other querier.")// 循环结构，全部通知querier结束for i := range stopChs {// 当前返回结果的goroutine不需要了，因为已经结束if i == rows.Index {continue}stopChs[i] <- struct{}{}}// 计划一个超时时间case <-time.After(5 * time.Second):println("all querier timeout.")// 循环结构，全部通知querier结束for i := range stopChs {stopChs[i] <- struct{}{}}}}()wg.Wait()
}

其中核心点：

获取了结果，通知结束
通过多个无缓冲channel通知goroutine结束
通过缓冲channel传递结果

执行结果示例：

querier  2  start fetch data, Need duration is  674  ms.
querier  6  start fetch data, Need duration is  695  ms.
querier  1  start fetch data, Need duration is  484  ms.
querier  4  start fetch data, Need duration is  544  ms.
querier  0  start fetch data, Need duration is  101  ms.
querier  7  start fetch data, Need duration is  233  ms.
querier  5  start fetch data, Need duration is  721  ms.
querier  3  start fetch data, Need duration is  727  ms.
querier  0  get result.
get first result from  0 . stop other querier.
querier  7  is stopping.
querier  2  is stopping.
querier  4  is stopping.
querier  6  is stopping.
querier  5  is stopping.
querier  1  is stopping.
querier  3  is stopping.

All 模式

Race模式是多个Goroutine获取相同的结果，优先使用快速响应的。

而All模式是多个Goroutine分别获取结果的各个部分，全部获取完毕后，组合成完整的数据，要保证全部的Goroutine都响应后，继续执行。

示例代码，核心逻辑：

一个整体内容Content，分为三个goroutine分别处理subject、tags、views三个部分
3个goroutine要全部执行完毕，数据才会整体获取
不会一直等待，设置超时时间。

本例中，使用具体的每个goroutine的标识方案来识别goroutine。对比Race方案使用的是索引号的方案来识别goroutine。

判定是否全部结束的方案，也是基于具体的标志key。

其中某次执行结果为：

start fetch  tags  data, need duration is  396  ms.
start fetch  views  data, need duration is  693  ms.
start fetch  subject  data, need duration is  597  ms.
querier  tags  get result.
received some part  tags
querier timeout. Content is incomplete.
querier  subject  is stopping.
querier  views  is stopping.
received content  { [go Goroutine Channel select] 0 }

无缓冲Channel+关闭作典型同步信号

基于：

无缓冲Channel是同步的
closed 的channel是可以接收内容的

以上两点原因，经常使用关闭无缓冲channel的方案来作为信号传递使用。前提是，信号纯粹是信号，没有其他含义，比如关闭时间等。

示例代码：

func SelectChannelCloseSignal() {wg := sync.WaitGroup{}// 定义无缓冲channel// 作为一个终止信号使用（啥功能的信号都可以，信号本身不分功能）ch := make(chan struct{})// goroutine，用来close, 表示
发出信号wg.Add(1)go func() {defer wg.Done()time.Sleep(2 * time.Second)fmt.Println("发出信号, close(ch)")close(ch)}()// goroutine，接收ch，表示接收信号wg.Add(1)go func() {defer wg.Done()// 先正常处理，等待ch的信号到来for {select {case <-ch:fmt.Println("收到信号, <-ch")returndefault:}// 正常的业务逻辑fmt.Println("业务逻辑处理中....")time.Sleep(300 * time.Millise
cond)}}()wg.Wait()
}// ====
> go test -run TestSelectChannelCloseSignal
业务逻辑处理中....
业务逻辑处理中....
业务逻辑处理中....
业务逻辑处理中....
业务逻辑处理中....
业务逻辑处理中....
业务逻辑处理中....
发出信号, close(ch)
收到信号, <-ch
PASS
ok      goConcurrency   2.168s

signal.Notify 信号通知监控

系统信号也是通过channel与应用程序交互，例如典型的 ctrl+c 中断程序， os.Interrupt，若不监控系统信号，ctrl+c后程序会直接终止，而如果监控了信号，那么可以在ctrl+c后，执行一系列的关闭处理，例如：

func SelectSignal() {// 一：模拟一段长时间运行的goroutinego func() {for {fmt.Println(time.Now().Format(".15.04.05.000"))time.Sleep(300 * time.Millisecond)}}()// 要求主goroutine等待上面的goroutine，方案：// 1. wg.Wait()// 2. time.Sleep()// 3. select{}// 持久阻塞//select {}// 二，监控系统的中断信号,interrupt// 1 创建channel，用于传递信号chSignal := make(chan os.Signal, 1)// 2 设置该channel可以监控哪些信号signal.Notify(chSignal, os.Interrupt)//signal.Notify(chSignal, os.Interrupt, os.Kill)//signal.Notify(chSignal) // 全部类型的信号都可以使用该channel// 3 监控channelselect {case <-chSignal:fmt.Println("received os signal: Interrupt")}
}

定时器与断续器，Timer&Ticker

Timer&Ticker是Go标准包time中定义的类型，通过Channel与程序进行通信。

time包中两个与Channel紧密关联的结构：

// 定时器
time.Timer
// 断续器
time.Ticker

定时器Timer类似于一次性闹钟
断续器Ticker类似于重复性闹钟，也成循环定时器

无论是一次性还是重复性计时器，都是通过Channel与应用程序交互的。我们通过监控Timer和Ticker返回的Channel，来确定是否到时的需求。

定时器

使用语法：

// time.NewTimer
func NewTimer(d Duration) *Timer

创建定时器。参数是Duration时间。返回为 *Timer。*Timer.C是用来接收到期通知的单向Channel。

type Timer struct {C <-chan Time
}

因此我们只要可从 *Timer.C上接收数据，就意味着定时器时间到。接收到的元素是 time.Time 类型数据，为到时时间。

示例：

func TimerA() {t := time.NewTimer(time.Second)println("Set the timer, \ttime is ", time.Now().String())now := <-t.Cprintln("The time is up, time is ", now.String())
}

Timer除了C之外，还有两个方法：

// 停止计时器
// 返回值bool类型，返回false，表示该定时器早已经停止，返回true表示由本次调用停止
func (t *Timer) Stop() bool// 重置定时器
// 返回值bool类型，返回false，表示该定时器早已经停止，返回true表示由本次调用重置
func (t *Timer) Reset(d Duration) bool

使用这两个方法，可以完整定时器的业务逻辑。

示例代码，简单的猜数字游戏，共猜5次，每次有超时时间3秒钟：

func TimerB() {ch := make(chan int)// 写channelgo func() {// 随机写入intfor {ch <- rand.Intn(10)time.Sleep(400 * time.Millisecond)}}()// 每局时间t := time.NewTimer(time.Second * 3)hint, miss := 0, 0// 统计结果，共玩5次for i := 0; i < 5; i++ {guess:for {select {case v := <-ch:println("guess value: ", v)if v == 4 {println("Bingo! some one hint the answer.")// 新游戏，重置定时器t.Reset(time.Second * 3)hint++break guess}case <-t.C:println("The time is up, no one hint.")miss++// 重新创建定时器t = time.NewTimer(time.Second * 3)break guess}}}println("Game Over! Hint ", hint, ", Miss ", miss)
}

代码在猜中或者时间到时，要重置或新建定时器。

如果不需要定时器的关闭和重置操作，可以使用函数：

func After(d Duration) <-chan Time

直接返回定时器到期的通知Channel。

func TimerC() {ch := time.After(time.Second)println("Set the timer, \ttime is ", time.Now().String())now := <-chprintln("The time is up, time is ", now.String())
}

如果希望在定时器到期时执行特定函数，可以使用如下函数：

func AfterFunc(d Duration, f func()) *Timer

该函数返回*Timer用于控制定时器，例如Stop或Reset.

断续器

也叫循环定时器。