Channel

channel

channel是Go语言中的一个核心类型，可以把它看成管道。并发核心单元通过它就可以发送或者接收数据进行通讯，这在一定程度上又进一步降低了编程的难度。

channel是一个数据类型，主要用来解决协程的同步问题以及协程之间数据共享（数据传递）的问题。

goroutine运行在相同的地址空间，因此访问共享内存必须做好同步。goroutine 奉行通过通信来共享内存，而不是共享内存来通信。

引⽤类型 channel可用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。

定义channel变量

和map类似，channel也一个对应make创建的底层数据结构的引用。

当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者和被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。

定义一个channel时，也需要定义发送到channel的值的类型。channel可以使用内置的make()函数来创建：

chan是创建channel所需使用的关键字。Type 代表指定channel收发数据的类型。

make(chan Type)  //等价于make(chan Type, 0)
make(chan Type, capacity)

当我们复制一个channel或用于函数参数传递时，我们只是拷贝了一个channel引用，因此调用者和被调用者将引用同一个channel对象。和其它的引用类型一样，channel的零值也是nil。

当 参数capacity= 0 时，channel 是无缓冲阻塞读写的；当capacity > 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity个元素才阻塞写入。

channel非常像生活中的管道，一边可以存放东西，另一边可以取出东西。channel通过操作符 <- 来接收和发送数据，发送和接收数据语法：

channel <- value      //发送value到channel
<-channel             //接收并将其丢弃
x := <-channel        //从channel中接收数据，并赋值给x
x, ok := <-channel    //功能同上，同时检查通道是否已关闭或者是否为空

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变的更加的简单，而不需要显式的lock。

示例代码：

package main

import (
    "fmt"
)

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

    go func() {
        defer fmt.Println("子协程结束")

        fmt.Println("子协程正在运行……")

        c <- 666 //666发送到c
    }()

    num := <-c //从c中接收数据，并赋值给num

    fmt.Println("num = ", num)
    fmt.Println("main协程结束")
}

程序运行结果：

无缓冲的channel

无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。

这种类型的通道要求发送goroutine和接收goroutine同时准备好，才能完成发送和接收操作。否则，通道会导致先执行发送或接收操作的 goroutine 阻塞等待。

这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。

阻塞：由于某种原因数据没有到达，当前协程（线程）持续处于等待状态，直到条件满足，才接触阻塞。

同步：在两个或多个协程（线程）间，保持数据内容一致性的机制。

下图展示两个 goroutine 如何利用无缓冲的通道来共享一个值：

• 在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行发送或者接收。
• 在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这时，这个 goroutine 会在通道中被锁住，直到交换完成
• 在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道里接收数据。这个 goroutine 一样也会在通道中被锁住，直到交换完成。
•  在第 4 步和第 5 步，进行交换，并最终，在第 6 步，两个 goroutine 都将它们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。

无缓冲的channel创建格式：

make(chan Type)   //等价于make(chan Type, 0)

如果没有指定缓冲区容量，那么该通道就是同步的，因此会阻塞到发送者准备好发送和接收者准备好接收。

示例代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int, 0) //创建无缓冲的通道 c 

    //内置函数 len 返回未被读取的缓冲元素数量，cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d
", len(c), cap(c))

    go func() {
        defer fmt.Println("子协程结束")

        for i := 0; i < 3; i++ {
            c <- i
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d
", i, len(c), cap(c))
        }
    }()

    time.Sleep(2 * time.Second) //延时2s

    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据，并赋值给num
        fmt.Println("num = ", num)
    }

    fmt.Println("main协程结束")
}

程序运行结果：

有缓冲的channel

有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个数据值的通道。

这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也不同。

只有通道中没有要接收的值时，接收动作才会阻塞。

只有通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换；有缓冲的通道没有这种保证。

示例图如下：

• 在第 1 步，右侧的 goroutine 正在从通道接收一个值。
• 在第 2 步，右侧的这个 goroutine独立完成了接收值的动作，而左侧的 goroutine 正在发送一个新值到通道里。
• 在第 3 步，左侧的goroutine 还在向通道发送新值，而右侧的 goroutine 正在从通道接收另外一个值。这个步骤里的两个操作既不是同步的，也不会互相阻塞。
• 最后，在第 4 步，所有的发送和接收都完成，而通道里还有几个值，也有一些空间可以存更多的值。

有缓冲的channel创建格式：

 make(chan Type, capacity)

如果给定了一个缓冲区容量，通道就是异步的。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞地进行。

示例代码：

func main() {
    c := make(chan int, 3) //带缓冲的通道

    //内置函数 len 返回未被读取的缓冲元素数量， cap 返回缓冲区大小
    fmt.Printf("len(c)=%d, cap(c)=%d
", len(c), cap(c))

    go func() {
        defer fmt.Println("子协程结束")

        for i := 0; i < 3; i++ {
            c <- i
            fmt.Printf("子协程正在运行[%d]: len(c)=%d, cap(c)=%d
", i, len(c), cap(c))
        }
    }()

    time.Sleep(2 * time.Second) //延时2s
    for i := 0; i < 3; i++ {
        num := <-c //从c中接收数据，并赋值给num
        fmt.Println("num = ", num)
    }
    fmt.Println("main协程结束")
}

程序运行结果：

关闭channel

如果发送者知道，没有更多的值需要发送到channel的话，那么让接收者也能及时知道没有多余的值可接收将是有用的，因为接收者可以停止不必要的接收等待。这可以通过内置的close函数来关闭channel实现。

示例代码：

package main

import (
    "fmt"
)

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

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 if data, ok := <-c; ok 那一行
        close(c)
    }()

    for {
        //ok为true说明channel没有关闭，为false说明管道已经关闭
        if data, ok := <-c; ok {
            fmt.Println(data)
        } else {
            break
        }
    }

    fmt.Println("Finished")
}

程序运行结果：

注意：

• channel不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的，才去关闭channel；
•  关闭channel后，无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值)；
• 关闭channel后，可以继续从channel接收数据；
• 对于nil channel，无论收发都会被阻塞。

可以使用 range 来迭代不断操作channel：

package main

import (
    "fmt"
)

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

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 for data := range c 那一行
        close(c)
    }()

    for data := range c {
        fmt.Println(data)
    }
    fmt.Println("Finished")
}

单向channel及应用

默认情况下，通道channel是双向的，也就是，既可以往里面发送数据也可以同里面接收数据。

但是，我们经常见一个通道作为参数进行传递而值希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。

单向channel变量的声明非常简单，如下：

var ch1 chan int       // ch1是一个正常的channel，是双向的
var ch2 chan<- float64 // ch2是单向channel，只用于写float64数据
var ch3 <-chan int     // ch3是单向channel，只用于读int数据

• chan<- 表示数据进入管道，要把数据写进管道，对于调用者就是输出。
• <-chan 表示数据从管道出来，对于调用者就是得到管道的数据，当然就是输入。

可以将 channel 隐式转换为单向队列，只收或只发，不能将单向 channel 转换为普通 channel：

 c := make(chan int, 3)
    var send chan<- int = c // send-only
    var recv <-chan int = c // receive-only
    send <- 1
    //<-send //invalid operation: <-send (receive from send-only type chan<- int)
    <-recv
    //recv <- 2 //invalid operation: recv <- 2 (send to receive-only type <-chan int)

    //不能将单向 channel 转换为普通 channel
    d1 := (chan int)(send) //cannot convert send (type chan<- int) to type chan int
    d2 := (chan int)(recv) //cannot convert recv (type <-chan int) to type chan int

示例代码：

//   chan<- //只写
func counter(out chan<- int) {
    defer close(out)
    for i := 0; i < 5; i++ {
        out <- i //如果对方不读 会阻塞
    }
}

//   <-chan //只读
func printer(in <-chan int) {
    for num := range in {
        fmt.Println(num)
    }
}

func main() {
    c := make(chan int) //   chan   //读写

    go counter(c) //生产者
    printer(c)    //消费者

    fmt.Println("done")
}

生产者消费者模型

单向channel最典型的应用是“生产者消费者模型”

所谓“生产者消费者模型”: 某个模块（函数等）负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、协程、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

单单抽象出生产者和消费者，还够不上是生产者／消费者模型。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。大概的结构如下图：

举一个寄信的例子来辅助理解一下，假设你要寄一封平信，大致过程如下：

    1．把信写好——相当于生产者制造数据

    2．把信放入邮筒——相当于生产者把数据放入缓冲区

    3．邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

4．邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

  那么，这个缓冲区有什么用呢？为什么不让生产者直接调用消费者的某个函数，直接把数据传递过去，而画蛇添足般的设置一个缓冲区呢？

缓冲区的好处大概如下：

1：解耦

假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。将来如果消费者的代码发生变化，可能会直接影响到生产者。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合度也就相应降低了。

接着上述的例子，如果不使用邮筒（缓冲区），须得把信直接交给邮递员。那你就必须要认识谁是邮递员。这就产生和你和邮递员之间的依赖（相当于生产者和消费者的强耦合）。万一哪天邮递员换人了，你还要重新认识下一个邮递员（相当于消费者变化导致修改生产者代码）。 而邮筒相对来说比较固定，你依赖它的成本比较低（相当于和缓冲区之间的弱耦合）。

2：处理并发

生产者直接调用消费者的某个方法，还有另一个弊端。由于函数调用是同步的（或者叫阻塞的），在消费者的方法没有返回之前，生产者只好一直等在那边。万一消费者处理数据很慢，生产者只能无端浪费时间。

使用了生产者／消费者模式之后，生产者和消费者可以是两个独立的并发主体。生产者把制造出来的数据往缓冲区一丢，就可以再去生产下一个数据。基本上不用依赖消费者的处理速度。

其实最当初这个生产者消费者模式，主要就是用来处理并发问题的。

从寄信的例子来看。如果没有邮筒，你得拿着信傻站在路口等邮递员过来收（相当于生产者阻塞）；又或者邮递员得挨家挨户问，谁要寄信（相当于消费者轮询）。

3：缓存

如果生产者制造数据的速度时快时慢，缓冲区的好处就体现出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。

假设邮递员一次只能带走1000封信。万一某次碰上情人节送贺卡，需要寄出去的信超过1000封，这时候邮筒这个缓冲区就派上用场了。邮递员把来不及带走的信暂存在邮筒中，等下次过来时再拿走。

示例代码：

package main

import "fmt"

// 此通道只能写，不能读。
func producer(out chan<- int)  {
   for i:= 0; i < 10; i++ {
      out <- i*i                  // 将 i*i 结果写入到只写channel
   }
   close(out)
}

// 此通道只能读，不能写
func consumer(in <-chan int)  {
   for num := range in {        // 从只读channel中获取数据
      fmt.Println("num =", num)
   }
}

func main()  {
   ch := make(chan int)        // 创建一个双向channel

   // 新建一个groutine， 模拟生产者，产生数据，写入 channel
   go producer(ch)             // channel传参， 传递的是引用。

   // 主协程，模拟消费者，从channel读数据，打印到屏幕
   consumer(ch)              // 与 producer 传递的是同一个 channel
}

简单说明：首先创建一个双向的channel，然后开启一个新的goroutine，把双向通道作为参数传递到producer方法中，同时转成只写通道。子协程开始执行循环，向只写通道中添加数据，这就是生产者。主协程，直接调用consumer方法，该方法将双向通道转成只读通道，通过循环每次从通道中读取数据，这就是消费者。

注意：channel作为参数传递，是引用传递。

模拟订单

在实际的开发中，生产者消费者模式应用也非常的广泛，例如：在电商网站中，订单处理，就是非常典型的生产者消费者模式。

当很多用户单击下订单按钮后，订单生产的数据全部放到缓冲区（队列）中，然后消费者将队列中的数据取出来发送者仓库管理等系统。

通过生产者消费者模式，将订单系统与仓库管理系统隔离开，且用户可以随时下单（生产数据）。如果订单系统直接调用仓库系统，那么用户单击下订单按钮后，要等到仓库系统的结果返回。这样速度会很慢。

下面模拟一个下订单处理的过程。

package main

import "fmt"

type OrderInfo struct {     // 创建结构体类型OrderInfo，只有一个id 成员
   id int
}

func producer2(out chan <- OrderInfo)  {       // 生成订单——生产者

   for i:=0; i<10; i++ {                  // 循环生成10份订单
      order := OrderInfo{id: i+1}
      out <- order                          // 写入channel
   }
   close(out)                // 写完，关闭channel
}

func consumer2(in <- chan OrderInfo)  {       // 处理订单——消费者

   for order := range in {                       // 从channel 取出订单
      fmt.Println("订单id为：", order.id)    // 模拟处理订单
   }
}

func main()  {
   ch := make(chan OrderInfo)  // 定义一个双向 channel， 指定数据类型为OrderInfo
   go producer2(ch)            // 建新协程，传只写channel
   consumer2(ch)               // 主协程，传只读channel
}

OrderInfo为订单信息，这里为了简单只定义了一个订单编号属性，然后生产者模拟10个订单，消费者对产生的订单进行处理。

定时器

time.Timer

Timer是一个定时器。代表未来的一个单一事件，你可以告诉timer你要等待多长时间。

type Timer struct {
   C <-chan Time
   r runtimeTimer
}

它提供一个channel，在定时时间到达之前，没有数据写入timer.C会一直阻塞。直到定时时间到，向channel写入值，阻塞解除，可以从中读取数据。

示例代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    //创建定时器，2秒后，定时器就会向自己的C字节发送一个time.Time类型的元素值
    timer1 := time.NewTimer(time.Second * 2)
    t1 := time.Now() //当前时间
    fmt.Printf("t1: %v
", t1)

    t2 := <-timer1.C
    fmt.Printf("t2: %v
", t2)

    //如果只是想单纯的等待的话，可以使用 time.Sleep 来实现
    timer2 := time.NewTimer(time.Second * 2)
    <-timer2.C
    fmt.Println("2s后")

    time.Sleep(time.Second * 2)
    fmt.Println("再一次2s后")

    <-time.After(time.Second * 2)
    fmt.Println("再再一次2s后")

    timer3 := time.NewTimer(time.Second)
    go func() {
        <-timer3.C
        fmt.Println("Timer 3 expired")
    }()

    stop := timer3.Stop() //停止定时器
    if stop {
        fmt.Println("Timer 3 stopped")
    }

    fmt.Println("before")
    timer4 := time.NewTimer(time.Second * 5)     //原来设置3s
    timer4.Reset(time.Second * 1)                //重新设置时间
    <-timer4.C
    fmt.Println("after")
}

定时器的常用操作：

1. 实现延迟功能

1) <-time.After(2 * time.Second) //定时2s，阻塞2s,2s后产生一个事件，往channel写内容

fmt.Println("时间到")

2) time.Sleep(2 * time.Second)

fmt.Println("时间到")

3) (3) 延时2s后打印一句话

timer := time.NewTimer(2 * time.Second)

<- timer.C

fmt.Println("时间到")

1. 定时器停止

timer := time.NewTimer(3 * time.Second)
    go func() {
        <-timer.C
        fmt.Println("子协程可以打印了，因为定时器的时间到")
    }()
    timer.Stop() //停止定时器

    for {
    }

     　2.定时器重置

timer := time.NewTimer(3 * time.Second)
    ok := timer.Reset(1 * time.Second) //重新设置为1s
    fmt.Println("ok = ", ok)
    <-timer.C
    fmt.Println("时间到")

 

time.Ticker

Ticker是一个周期触发定时的计时器，它会按照一个时间间隔往channel发送系统当前时间，而channel的接收者可以以固定的时间间隔从channel中读取事件。

type Ticker struct {
   C <-chan Time // The channel on which the ticks are delivered.
   r runtimeTimer
}

示例代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    //创建定时器，每隔1秒后，定时器就会给channel发送一个事件(当前时间)
    ticker := time.NewTicker(time.Second * 1)

    i := 0
    go func() {
        for { //循环
            <-ticker.C
            i++
            fmt.Println("i = ", i)

            if i == 5 {
                ticker.Stop() //停止定时器
            }
        }
    }() //别忘了()

    //死循环，特地不让main goroutine结束
    for {
    }
}

总结：

1.系统文件： 在程序启动运行时，自动打开，运行结束，自动关闭。

　　键盘（硬件）―― 标准输入（文件）stdin ―― 0

　　屏幕（硬件）―― 标准输出（文件）stdout ―― 1

　　屏幕（硬件）―― 标准错误（文件）stderr ―― 2

2.channel： 通道、管道。 一个读端、一个写端。

　　创建 ： make(chan关键字 数据类型，容量) ―― make(chan bool，0)

无缓冲特性：
　　　　　　同一时刻，同时有 读、写两端把持 channel。

　　　　　　如果只有读端，没有写端，那么 “读端”阻塞。

　　　　　　如果只有写端，没有读端，那么 “写端”阻塞。

　　　　读channel： <- channel

　　　　写channel： channel <- 数据

channel 使用注意事项：

　　　　　　1. 在一个 goroutine 中使用 一个 channel 的 read、write。

　　　　　　　　　　fatal error: all goroutines are asleep - deadlock!

　　　　　　2. 在不同 go 程 中，使用无缓冲 channel 通信， 同时有 read 、 write 两端。

　　　　　　3. 在创建子 go 程之前，对 channel 进行 读、写操作。

　　channel类型：

　　　　　　无缓冲channel： 完成数据通信 同步

　　　　　　　　ch :=make(chan int) == cha :=make(chan int, 0)

　　　　　　　　不能在 channel 中存放任何数据。 len()/cap() --> 0

　　　　　　有缓冲channel：

　　　　　　　　channel 中自带缓冲区。创建时可以指定缓冲区的大小。

　　　　　　　　w：直到缓冲区被填满后，写端才会阻塞。

　　　　　　　　r：缓冲区被读空，读端才会阻塞。

　　　　　　　　len：代表缓冲区中，剩余元素个数，

　　　　　　　　cap：代表缓冲区的容量。

　　同步通信： 数据发送端，和数据接收端，必须同时在线。 ―― 无缓冲channel

　　　　　　　　打电话。

　　异步通信：数据发送端，发送完数据，立即返回。数据接收端有可能立即读取，也可能延迟处理。 ―― 有缓冲channel

　　　　　　　　发信息。短信。

关闭channel：

　　　　　　关闭channel方法：close(channel名称）

　　　　判断是否关闭：

　　　　　　　　方法1： if value, ok := <-ch; ok == true {

　　　　　　　　　　　　1) 如果写端没有写数据，也没有关闭。<-ch; 会阻塞 ---【重点】

　　　　　　　　　　　　2）如果写端写数据， value 保存 <-ch 读到的数据。 ok 被设置为 true

　　　　　　　　　　　　3）如果写端关闭。 value 为数据类型默认值。ok 被设置为 false

　　　　　　1. 对一个已经关闭的channel “写”操作，报错！

　　　　　　　　panic: send on closed channel

　　　　　　2. 对一个已经关闭的channel “读”操作，不报错！会读到数据类型的 默认值。

　　　　　　　　方法2： 简便判断 channel 关闭。―― range

　　　　　　　　　　for num := range ch { 【注意】：ch 不能使用 <-ch
　　　　　　　　　　　　　　　　　　　　}

　　channel按数据传递方向划分：

　　　　　　1. 双向channel

　　　　　　　　　　make(chan int)

　　　　　　　　　　双向channel既可以给 单向读channel赋值，也可以给单向写channel赋值。

　　　　　　2. 单向写channel

　　　　　　　　　　var send chan<- int。

　　　　　　　　　　不能对单向写channel 进行 读操作。

　　　　　　3. 单向读channel

　　　　　　　　　　var recv <-chan int

　　　　　　　　　　不能对单向读channel 进行 写操作。

　　　　　　　　　　单向 channel 不能给双向 channel 赋值。 单向读channel 不能关闭。错误： invalid operation: close(recv) (cannot close receive-only channel)

channel 作为函数参数传参时，传递的是 “引用”

　　　　　　生产者、消费者模型:

　　　　　　生产者模块、消费者模块、缓冲区

　　　　　缓冲区作用：   1. 解耦： 生产者和消费者之间 降低耦合度。 任意一方修改，不会直接影响对端。

　　　　　　　　　　　　2. 实现并发：借助异步通信机制，在生产者、消费者等多个 go程间实现并行通信。

　　　　　　　　　　　　3. 缓存：借助缓冲区，缓存数据，从而提高生产者、消费者效率。

　　练习：实现生产者、消费者模型。 模拟订单。

定时器：
　　　　Timer： 一次性定时。

　　　　1. Timer 定时：

　　　　　　　　1）. 创建 Timer 对象。

　　　　　　　　　　　　myTimer := time.NewTimer(time.Second * 2)

　　　　　　　　2）. 从 Timer 对象的 C 成员变量 读。

　　　　　　　　　　　　默认读 ―― 阻塞，定时时长到达后，系统写入当前时间，解除阻塞。
　　　　2. Time.After()

　　　　　　　　　　　　将上两步 合并。

　　　　　　　　　　time := <-time.After(time.Second * 2)

　　　　　　　　　　　　默认读 ―― 阻塞，定时时长到达后，系统写入当前时间，解除阻塞。

　　　　3. Timer 的停止

　　　　　　　　　　myTimer := time.NewTimer(time.Second * 2)

　　　　　　　　　　myTimer.stop()

　　　　4. Timer 的重置

　　　　　　　　　　myTimer := time.NewTimer(time.Second * 20)

　　　　　　　　　　myTimer.Reset(time.Second * 2)

　　　　　　　　　　<-myTimer.C 这个读操作，2秒后会被执行。

Ticker： 周期性定时。

　　　　1） 创建 Ticker 对象。

　　　　　　　　myTicker := time.NewTicker(time.Second * 2)

　　　　2） 在 for 循环中 取 myTicker.C 中的数据（系统当前时间）

　　　　　　　　for {
　　　　　　　　<- myTicker.C // 每隔 2 秒，系统会向 myTicker.C channel 中写时间。
　　　　　　　　}