cfcbb4227f
This does not yet include support for the //go:embed directive added in this release. * Makefile.am (check-runtime): Don't create check-runtime-dir. (mostlyclean-local): Don't remove check-runtime-dir. (check-go-tool, check-vet): Copy in go.mod and modules.txt. (check-cgo-test, check-carchive-test): Add go.mod file. * Makefile.in: Regenerate. Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/280172
70 lines
2.2 KiB
Go
70 lines
2.2 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package time
|
|
|
|
import "errors"
|
|
|
|
// 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
|
|
}
|
|
|
|
// NewTicker returns a new Ticker containing a channel that will send
|
|
// the time on the channel after each tick. The period of the ticks is
|
|
// specified by the duration argument. The ticker will adjust the time
|
|
// interval or drop ticks to make up for slow receivers.
|
|
// The duration d must be greater than zero; if not, NewTicker will
|
|
// panic. Stop the ticker to release associated resources.
|
|
func NewTicker(d Duration) *Ticker {
|
|
if d <= 0 {
|
|
panic(errors.New("non-positive interval for NewTicker"))
|
|
}
|
|
// Give the channel a 1-element time buffer.
|
|
// If the client falls behind while reading, we drop ticks
|
|
// on the floor until the client catches up.
|
|
c := make(chan Time, 1)
|
|
t := &Ticker{
|
|
C: c,
|
|
r: runtimeTimer{
|
|
when: when(d),
|
|
period: int64(d),
|
|
f: sendTime,
|
|
arg: c,
|
|
},
|
|
}
|
|
startTimer(&t.r)
|
|
return t
|
|
}
|
|
|
|
// Stop turns off a ticker. After Stop, no more ticks will be sent.
|
|
// Stop does not close the channel, to prevent a concurrent goroutine
|
|
// reading from the channel from seeing an erroneous "tick".
|
|
func (t *Ticker) Stop() {
|
|
stopTimer(&t.r)
|
|
}
|
|
|
|
// Reset stops a ticker and resets its period to the specified duration.
|
|
// The next tick will arrive after the new period elapses.
|
|
func (t *Ticker) Reset(d Duration) {
|
|
if t.r.f == nil {
|
|
panic("time: Reset called on uninitialized Ticker")
|
|
}
|
|
modTimer(&t.r, when(d), int64(d), t.r.f, t.r.arg, t.r.seq)
|
|
}
|
|
|
|
// Tick is a convenience wrapper for NewTicker providing access to the ticking
|
|
// channel only. While Tick is useful for clients that have no need to shut down
|
|
// the Ticker, be aware that without a way to shut it down the underlying
|
|
// Ticker cannot be recovered by the garbage collector; it "leaks".
|
|
// Unlike NewTicker, Tick will return nil if d <= 0.
|
|
func Tick(d Duration) <-chan Time {
|
|
if d <= 0 {
|
|
return nil
|
|
}
|
|
return NewTicker(d).C
|
|
}
|