timer

Documentation

Overview

Package timer provides various enhanced timer functions.

Index

• func SleepContext(ctx context.Context, duration time.Duration) error
• type RandTicker
  • func NewRandTicker(d, variance time.Duration) *RandTicker
  • func (tkr *RandTicker) Stop()
• type RateLimiter
  • func NewRateLimiter(d time.Duration) *RateLimiter
  • func (r *RateLimiter) AllowOne()
  • func (r *RateLimiter) Diff() int64
  • func (r *RateLimiter) Do(f func() error) (err error)
  • func (r *RateLimiter) DoEmpty()
  • func (r *RateLimiter) Stop()
• type SuspendableTicker
  • func NewSuspendableTicker(d time.Duration, initiallySuspended bool) *SuspendableTicker
  • func (s *SuspendableTicker) Resume()
  • func (s *SuspendableTicker) Stop()
  • func (s *SuspendableTicker) Suspend()
  • func (s *SuspendableTicker) TickAfter(d time.Duration)
  • func (s *SuspendableTicker) TickNow()
• type Timer
  • func NewTimer(interval time.Duration) *Timer
  • func (tm *Timer) Interval() time.Duration
  • func (tm *Timer) Running() bool
  • func (tm *Timer) SetInterval(ns time.Duration)
  • func (tm *Timer) Start(keephouse func())
  • func (tm *Timer) Stop()
  • func (tm *Timer) Trigger()
  • func (tm *Timer) TriggerAfter(duration time.Duration)

Functions

func SleepContext

func SleepContext(ctx context.Context, duration time.Duration) error

SleepContext sleeps for the specified time period. If the context expires early, it returns an error.

Types

type RandTicker

type RandTicker struct {
	C <-chan time.Time
	// contains filtered or unexported fields
}

RandTicker is just like time.Ticker, except that it adds randomness to the events.

func NewRandTicker

func NewRandTicker(d, variance time.Duration) *RandTicker

NewRandTicker creates a new RandTicker. d is the duration, and variance specifies the variance. The ticker will tick every d +/- variance.

func (*RandTicker) Stop

func (tkr *RandTicker) Stop()

Stop stops the ticker and closes the underlying channel.

type RateLimiter

type RateLimiter struct {
	// contains filtered or unexported fields
}

RateLimiter runs given tasks, at no more than one per defined duration. For example, we can create a RateLimiter of 1second. Then, we can ask it, over time, to run many tasks. It will only ever run a single task in any 1 second time frame. The rest are ignored.

func NewRateLimiter

func NewRateLimiter(d time.Duration) *RateLimiter

NewRateLimiter creates a new limiter with given duration. It is immediately ready to run tasks.

func (*RateLimiter) AllowOne

func (r *RateLimiter) AllowOne()

AllowOne allows the next Do() call to run, even if the rate limiter would otherwise skip it.

func (*RateLimiter) Diff

func (r *RateLimiter) Diff() int64

Diff returns the logical clock diff between the ticker and the last Do() call.

func (*RateLimiter) Do

func (r *RateLimiter) Do(f func() error) (err error)

Do runs a given func assuming rate limiting allows. This function is thread safe. f may be nil, in which case it is not invoked.

func (*RateLimiter) DoEmpty

func (r *RateLimiter) DoEmpty()

DoEmpty is a convenience method to invoke Do() with no function.

func (*RateLimiter) Stop

func (r *RateLimiter) Stop()

Stop terminates rate limiter's operation and will not allow any more Do() executions.

type SuspendableTicker

type SuspendableTicker struct {

	// C is user facing
	C chan time.Time
	// contains filtered or unexported fields
}

SuspendableTicker is similar to time.Ticker, but also offers Suspend() and Resume() functions. While the ticker is suspended, nothing comes from the time channel C

func NewSuspendableTicker

func NewSuspendableTicker(d time.Duration, initiallySuspended bool) *SuspendableTicker

NewSuspendableTicker creates a new suspendable ticker, indicating whether the ticker should start suspendable or running

func (*SuspendableTicker) Resume

func (s *SuspendableTicker) Resume()

Resume re-enables time events on channel C

func (*SuspendableTicker) Stop

func (s *SuspendableTicker) Stop()

Stop completely stops the timer, like time.Timer

func (*SuspendableTicker) Suspend

func (s *SuspendableTicker) Suspend()

Suspend stops sending time events on the channel C time events sent during suspended time are lost

func (*SuspendableTicker) TickAfter

func (s *SuspendableTicker) TickAfter(d time.Duration)

TickAfter generates a tick after given duration has passed. It runs asynchronously and returns immediately.

func (*SuspendableTicker) TickNow

func (s *SuspendableTicker) TickNow()

TickNow generates a tick at this point in time. It may block if nothing consumes the tick.

type Timer

type Timer struct {
	// contains filtered or unexported fields
}

Timer provides timer functionality that can be controlled by the user. You start the timer by providing it a callback function, which it will call at the specified interval.

var t = timer.NewTimer(1e9)
t.Start(KeepHouse)

func KeepHouse() {
	// do house keeping work
}

You can stop the timer by calling t.Stop, which is guaranteed to wait if KeepHouse is being executed.

You can create an untimely trigger by calling t.Trigger. You can also schedule an untimely trigger by calling t.TriggerAfter.

The timer interval can be changed on the fly by calling t.SetInterval. A zero value interval will cause the timer to wait indefinitely, and it will react only to an explicit Trigger or Stop.

func NewTimer

func NewTimer(interval time.Duration) *Timer

NewTimer creates a new Timer object

func (*Timer) Interval

func (tm *Timer) Interval() time.Duration

Interval returns the current interval.

func (*Timer) Running

func (tm *Timer) Running() bool

func (*Timer) SetInterval

func (tm *Timer) SetInterval(ns time.Duration)

SetInterval changes the wait interval. It will cause the timer to restart the wait.

func (*Timer) Start

func (tm *Timer) Start(keephouse func())

Start starts the timer.

func (*Timer) Stop

func (tm *Timer) Stop()

Stop will stop the timer. It guarantees that the timer will not execute any more calls to keephouse once it has returned.

func (*Timer) Trigger

func (tm *Timer) Trigger()

Trigger will cause the timer to immediately execute the keephouse function. It will then cause the timer to restart the wait.

func (*Timer) TriggerAfter

func (tm *Timer) TriggerAfter(duration time.Duration)

TriggerAfter waits for the specified duration and triggers the next event.