go语言标准库里的定时器使用场景

(1)time.NewTimer，time.NewTicker，time.Tick的使用以下：

package main
 
import (
    "errors"
    "fmt"
    "golang.org/x/sync/errgroup"
    "time"
)
 
/**
* ticker只要定义完成，今后刻开始计时，不须要任何其余的操做，每隔固定时间都会触发。
* timer定时器，是到固定时间后值只会执行一次
* 若是timer定时器要每隔间隔的时间执行，实现ticker的效果，使用 func (t *Timer) Reset(d Duration) bool
 */
func main() {
    var g errgroup.Group
 
    g.Go(func() error {
        timer := time.NewTimer(1 * time.Second)
 
        for {
            select {
            case <-timer.C:
                println("1_Tokyo_NewYork_London")
                timer.Reset(1 * time.Second)
                // 若要中止定时器就使用以下代码，这样会释放资源
                // timer.Stop()
            }
            // break
        }
 
        return nil
    })
 
    g.Go(func() error {
        ticker := time.NewTicker(1 * time.Second)
 
        for {
            select {
            case <-ticker.C:
                println("2_NewYork_London_Tokyo")
                // 若要中止定时器就使用以下代码，这样会释放资源
                // ticker.Stop()
            }
            // break
        }
 
        return errors.New("sgdagf")
    })
    // 上一个协程实现的功能同样的，但这time.Tick没法中止，也就是没法释放资源！
    g.Go(func() error {
        for {
            select {
            case <-time.Tick(1 * time.Second):
                println("3_Singapore_London_Tokyo")
            }
 
            // fmt.Println(<-time.Tick(2 * time.Second))
        }
    })
 
    if err := g.Wait(); err != nil {
        fmt.Println("Err:",err)
    } else {
        println("finish")
    }
}

(2)time.AfterFunc使用以下：

package main
 
import "time"
 
func main() {
    f := func() { println("Tokyo_London_NewYork") }
    // AfterFunc的内部又启动了一个协程，且这个定时器到了定时时间后，只会执行一次！
    time.AfterFunc(2*time.Second, f)
    time.Sleep(5 * time.Second)
}

下面这个状况会发生死锁！

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    fmt.Println(time.Now())
    f := func() { println("Tokyo_London_NewYork") }
    // 执行下面的代码，会发生死锁！
    fmt.Println(<-time.AfterFunc(2*time.Second, f).C)
}

(3)time.After使用以下：

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    fmt.Println("3 second before:",time.Now())
    // After函数到了定时时间后只有执行一次!而且返回过了定时时间后的当前时间！
    fmt.Println("3 second after:",    <-time.After(3*time.Second))
}