ticker

Documentation

Index

• type Force
  • func NewForce(interval time.Duration) *Force
  • func (m *Force) Pause()
  • func (m *Force) Resume()
  • func (m *Force) Stop()
  • func (m *Force) Ticks() <-chan time.Time
• type T
  • func New(interval time.Duration) *T
  • func (t *T) Pause()
  • func (t *T) Resume()
  • func (t *T) Stop()
  • func (t *T) Ticks() <-chan time.Time
• type Ticker

Types

type Force

type Force struct {

	// Force is used to force-feed a ticks into the ticker. Useful for
	// debugging when trying to wake an event.
	Force chan time.Time
	// contains filtered or unexported fields
}

Force implements the Ticker interface, and provides a method of force-feeding ticks, even while paused.

func NewForce

func NewForce(interval time.Duration) *Force

NewForce returns a Force ticker, used for testing and debugging. It supports the ability to force-feed events that get output by the

func (*Force) Pause

func (m *Force) Pause()

Pause suspends the underlying ticker, such that Ticks() stops signaling at regular intervals.

NOTE: Part of the Ticker interface.

func (*Force) Resume

func (m *Force) Resume()

Resume starts underlying time.Ticker and causes the ticker to begin delivering scheduled events.

NOTE: Part of the Ticker interface.

func (*Force) Stop

func (m *Force) Stop()

Stop suspends the underlying ticker, such that Ticks() stops signaling at regular intervals, and permanently frees up any resources.

NOTE: Part of the Ticker interface.

func (*Force) Ticks

func (m *Force) Ticks() <-chan time.Time

Ticks returns a receive-only channel that delivers times at the ticker's prescribed interval when active. Force-fed ticks can be delivered at any time.

NOTE: Part of the Ticker interface.

type T

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

T is the production implementation of the resumable Ticker interface. This allows various components to toggle their need for tick events, which may vary depending on system load.

func New

func New(interval time.Duration) *T

New returns a new ticker that signals with the given interval when not paused. The ticker starts off inactive.

func (*T) Pause

func (t *T) Pause()

Pause suspends the underlying ticker, such that Ticks() stops signaling at regular intervals.

NOTE: Part of the Ticker interface.

func (*T) Resume

func (t *T) Resume()

Resume starts underlying time.Ticker and causes the ticker to begin delivering scheduled events.

NOTE: Part of the Ticker interface.

func (*T) Stop

func (t *T) Stop()

Stop suspends the underlying ticker, such that Ticks() stops signaling at regular intervals, and permanently frees up any resources. For this implementation, this is equivalent to Pause.

NOTE: Part of the Ticker interface.

func (*T) Ticks

func (t *T) Ticks() <-chan time.Time

Ticks returns a receive-only channel that delivers times at the ticker's prescribed interval. This method returns nil when the ticker is paused.

NOTE: Part of the Ticker interface.

type Ticker

type Ticker interface {
	// Ticks returns a read-only channel delivering ticks according to a
	// prescribed interval. The value returned does not need to be the same
	// channel, and may be nil.
	//
	// NOTE: Callers should assume that reads from Ticks() are stale after
	// any invocations of Resume, Pause, or Stop.
	Ticks() <-chan time.Time

	// Resume starts or resumes the underlying ticker, such that Ticks()
	// will fire at regular intervals. After calling Resume, Ticks() should
	// minimally send ticks at the prescribed interval.
	//
	// NOTE: It MUST be safe to call Resume at any time, and more than once
	// successively.
	Resume()

	// Pause suspends the underlying ticker, such that Ticks() stops
	// signaling at regular intervals. After calling Pause, the ticker
	// should not send any ticks scheduled with the chosen interval. Forced
	// ticks are still permissible, as in the case of the Force Ticker.
	//
	// NOTE: It MUST be safe to call Pause at any time, and more than once
	// successively.
	Pause()

	// Stop suspends the underlying ticker, such that Ticks() stops
	// signaling at regular intervals, and permanently frees up any
	// remaining resources.
	//
	// NOTE: The behavior of a Ticker is undefined after calling Stop.
	Stop()
}

Ticker defines a resumable ticker interface, whose activity can be toggled to free up resources during periods of inactivity.

Example of resuming ticker:

ticker.Resume() // can remove to keep inactive at first
defer ticker.Stop()
for {
  select {
    case <-ticker.Tick():
      if shouldGoInactive {
        ticker.Pause()
        continue
      }
      ...

    case <-otherEvent:
      ...
      if shouldGoActive {
        ticker.Resume()
      }
  }

NOTE: ONE DOES NOT SIMPLY assume that Tickers are safe for concurrent access.