...
Run Format

Source file src/time/tick.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 with a period specified by the duration argument.
  // It adjusts the intervals or drops 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 read from the channel succeeding
  // incorrectly.
  func (t *Ticker) Stop() {
  	stopTimer(&t.r)
  }
  
  // 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
  }
  

View as plain text