go语言设置定时器的方法-创新互联

小编给大家分享一下go语言设置定时器的方法,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家阅读完这篇文章后大有收获,下面让我们一起去了解一下吧!

创新互联长期为千余家客户提供的网站建设服务,团队从业经验10年,关注不同地域、不同群体,并针对不同对象提供差异化的产品和服务;打造开放共赢平台,与合作伙伴共同营造健康的互联网生态环境。为嘉祥企业提供专业的网站设计制作、网站设计,嘉祥网站改版等技术服务。拥有十载丰富建站经验和众多成功案例,为您定制开发。

go语言设置定时器的方法:1、通过“time.NewTicker()”方法创建,其中ticker会按照设定的间隔时间触发;2、通过“time.NewTimer()”方法创建,其中timer只会执行一词;3、使用“After()”来创建。

Go语言中定时器的使用

GO语言在time包中提供了三种定时器的使用方式:

1.第一种:ticker

// A Ticker holds a channel that delivers `ticks' of a clock
// at intervals.
type Ticker struct {
	C <-chan Time // The channel on which the ticks are delivered.
	r runtimeTimer
}

通过time.NewTicker() 创建,这种类型,ticker会不断的按照设定的间隔时间触发,除非主动终止运行。


2.第二种:timer

// The Timer type represents a single event.
// When the Timer expires, the current time will be sent on C,
// unless the Timer was created by AfterFunc.
// A Timer must be created with NewTimer or AfterFunc.
type Timer struct {
	C <-chan Time
	r runtimeTimer
}

通过 time.NewTimer() 创建,这种类型,timer只会执行一次,当然,可以在执行完以后通过调用timer.Reset() 让定时器再次工作,并可以更改时间间隔。


3.第三种:After()

// After waits for the duration to elapse and then sends the current time
// on the returned channel.
// It is equivalent to NewTimer(d).C.
// The underlying Timer is not recovered by the garbage collector
// until the timer fires. If efficiency is a concern, use NewTimer
// instead and call Timer.Stop if the timer is no longer needed.
func After(d Duration) <-chan Time {
	return NewTimer(d).C
}

从代码可以看到,After()其实是Timer的一个语法糖。



下面通过代码演示一下三种方式的使用:

1.Ticker

ticker := time.NewTicker(time.Second * 1) // 运行时长
    ch := make(chan int)
    go func() {
        var x int
        for x < 10 {
            select {
            case <-ticker.C:
                x++
                fmt.Printf("%d\n", x)
            }
        }
        ticker.Stop()
        ch <- 0
    }()
    <-ch                                    // 通过通道阻塞,让任务可以执行完指定的次数。

该ticker每1秒触发一次,即ticker.C中每一秒会有一个内容加入,最后通过向ch中写入数字,让程序解除阻塞,继续执行。

2.Timer

timer := time.NewTimer(time.Second * 1) // timer 只能按时触发一次,可通过Reset()重置后继续触发。
    go func() {
        var x int
        for {
            select {
            case <-timer.C:
                x++
                fmt.Printf("%d,%s\n", x, time.Now().Format("2006-01-02 15:04:05"))
                if x < 10 {
                    timer.Reset(time.Second * 2)
                } else {
                    ch <- x
                }
            }
        }
    }()
    <-ch

3.After()

// 阻塞一下,等待主进程结束
    tt := time.NewTimer(time.Second * 10)
    <-tt.C
    fmt.Println("over.")

    <-time.After(time.Second * 4)
    fmt.Println("再等待4秒退出。tt 没有终止,打印出 over 后会看见在继续执行...")
    tt.Stop()
    <-time.After(time.Second * 2)
    fmt.Println("tt.Stop()后, tt 仍继续执行,只是关闭了 tt.C 通道。")

4.我们可以利用这些基本的方法,设计自己的定时任务管理。

type jobFunc2 func(j *job)

type job struct {
    jf     jobFunc2
    params map[string]interface{}
    ch     chan int
}

func NewJob() *job {
    return &job{
        params: make(map[string]interface{}),
        ch:     make(chan int),
    }
}

func (j *job) Run(t time.Duration) {
    ticker := time.NewTicker(time.Second * t)
    go func() {
        for {
            select {
            case <-ticker.C:
                j.jf(j)
            case <-j.ch:
                fmt.Println("收到结束指令")
                ticker.Stop()
                break
            }
        }
    }()

}

func main() {
    j := NewJob()
    j.jf = func(jj *job) {
        fmt.Println("定时任务执行...", time.Now().Format("15:04:05 2006-02-01"), jj.params)
    }
    j.params["p1"] = "第一个参数"
    j.params["p2"] = 100
    j.Run(1)

    // 阻塞一下,等待主进程结束
    tt := time.NewTimer(time.Second * 10)
    <-tt.C
    fmt.Println("over.")

    <-time.After(time.Second * 4)
    fmt.Println("再等待4秒退出。tt 没有终止,打印出 over 后会看见在继续执行...")
    tt.Stop()
    <-time.After(time.Second * 2)
    fmt.Println("tt.Stop()后, tt 仍继续执行,只是关闭了 tt.C 通道。")
}

部分执行结果截图:

go语言设置定时器的方法

最后补充一下,通过channel去终止任务的执行。

// 阻塞一下,等待主进程结束
    tt := time.NewTimer(time.Second * 10)
    <-tt.C
    fmt.Println("over.")

    <-time.After(time.Second * 4)
    fmt.Println("再等待4秒退出。tt 没有终止,打印出 over 后会看见在继续执行...")
    tt.Stop()
    <-time.After(time.Second * 2)
    fmt.Println("tt.Stop()后, tt 仍继续执行,只是关闭了 tt.C 通道。")
    j.ch <- 0
    <-time.After(time.Second * 2)
    fmt.Println("又等了2秒钟...这两秒钟可以看到 tt 没干活了...")

go语言设置定时器的方法


在GO语言编写中,要熟练使用channel

以上是“go语言设置定时器的方法”这篇文章的所有内容,感谢各位的阅读!相信大家都有了一定的了解,希望分享的内容对大家有所帮助,如果还想学习更多知识,欢迎关注创新互联行业资讯频道!


新闻名称:go语言设置定时器的方法-创新互联
链接地址:http://pwwzsj.com/article/cedpop.html