Go语言学习笔记20.定时器、超时

定时器Timer

Timer是利用channel来实现定时的效果，他会在给定的时候向timer.C(是个channel)中输入一个时间，在此之前timer.C会阻塞。

package main

import (
    "fmt"
    "time"
)

func main() {

    timer := time.NewTimer(2 * time.Second) //定时2秒，向timer.C中写入一个时间
    fmt.Printf("t1: %v\n", time.Now())

    t2 := <-timer.C  //没有消息会阻塞
    fmt.Printf("t2: %v\n", t2)

    //如果只想延时也可以用sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("t3: %v\n", time.Now())

    //简写
    <-time.After(2 * time.Second)
    fmt.Printf("t4: %v\n", time.Now())
    
}

定时器是可以重置和停止的

    fmt.Println("t0 = ",time.Now())

    timer := time.NewTimer(3 * time.Second)
    t1 := timer.Reset(1 * time.Second) //重新设置为1s
    fmt.Println("t1 = ", t1)

    <-timer.C
    fmt.Println("t2 = ",time.Now()) //和t1只隔1秒

停止：

timer2.Stop() //停止定时器

Ticker

Ticker等于是个死循环的Timer，每隔一段时间写入一次

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(1 * time.Second)

    i := 0
    for {
        <-ticker.C

        i++
        fmt.Println("i = ", i)

        if i == 5 {
            ticker.Stop()
            break
        }
    }

}

select

select可以监听channel上的数据流动。

select {
    case <-chan1:
        // 如果chan1成功读到数据，则进行该case处理语句
    case chan2 <- 1:
        // 如果成功向chan2写入数据，则进行该case处理语句
    default:
        // 如果上面都没有成功，则进入default处理流程
}

可以用来写触发器和超时判断。

//fibonacci     1 1 2 3 5 8

package main

import (
    "fmt"
)

//生成斐波拉契数列
func fibonacci(consumers chan<- int, quit <-chan bool) {
    x, y := 1, 1
    //死循环，由于channel没有缓冲区，所以没有消费者读取就会一直堵塞
    for {
        //监听channel数据的流动
        select {
            case consumers <- x: //写入成功就处理
                x, y = y, x+y
                fmt.Println("x = ", x)
                fmt.Println("y = ", y)
            case flag := <-quit:
                fmt.Println("要停止的标志 = ", flag)
                return
        }
    }
}

func main() {
    consumers := make(chan int)  //注意是没有缓冲区的
    quit := make(chan bool) //程序是否结束

    //消费者，从channel读取内容
    //新建协程
    go func() {
        for i := 0; i < 16; i++ {
            num := <-consumers
            fmt.Println(num)
        }
        //可以停止
        quit <- true
    }() //别忘了()

    //生产者，产生数字，写入channel
    fibonacci(consumers, quit)

}

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int)
    quit := make(chan bool)

    //新开一个协程
    go func() {
        for {
            select {
                case num := <-ch:
                    fmt.Println("num = ", num)
                case <-time.After(3 * time.Second):
                    fmt.Println("超时")
                    quit <- true
            }
        }

    }() //别忘了()

    for i := 0; i < 5; i++ {
        ch <- i
        time.Sleep(time.Second)
    }

    //阻塞3秒则退出
    <-quit
    fmt.Println("程序结束")

}