libgo/go/time/sleep.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package time
   6
   7 // Sleep pauses the current goroutine for at least the duration d.
   8 // A negative or zero duration causes Sleep to return immediately.
   9 func Sleep(d Duration)
  10
  11 // runtimeNano returns the current value of the runtime clock in nanoseconds.
  12 func runtimeNano() int64
  13
  14 // Interface to timers implemented in package runtime.
  15 // Must be in sync with ../runtime/runtime.h:/^struct.Timer$
  16 type runtimeTimer struct {
  17         i      int
  18         when   int64
  19         period int64
  20         f      func(interface{}, uintptr) // NOTE: must not be closure
  21         arg    interface{}
  22         seq    uintptr
  23 }
  24
  25 // when is a helper function for setting the 'when' field of a runtimeTimer.
  26 // It returns what the time will be, in nanoseconds, Duration d in the future.
  27 // If d is negative, it is ignored. If the returned value would be less than
  28 // zero because of an overflow, MaxInt64 is returned.
  29 func when(d Duration) int64 {
  30         if d <= 0 {
  31                 return runtimeNano()
  32         }
  33         t := runtimeNano() + int64(d)
  34         if t < 0 {
  35                 t = 1<<63 - 1 // math.MaxInt64
  36         }
  37         return t
  38 }
  39
  40 func startTimer(*runtimeTimer)
  41 func stopTimer(*runtimeTimer) bool
  42
  43 // The Timer type represents a single event.
  44 // When the Timer expires, the current time will be sent on C,
  45 // unless the Timer was created by AfterFunc.
  46 // A Timer must be created with NewTimer or AfterFunc.
  47 type Timer struct {
  48         C <-chan Time
  49         r runtimeTimer
  50 }
  51
  52 // Stop prevents the Timer from firing.
  53 // It returns true if the call stops the timer, false if the timer has already
  54 // expired or been stopped.
  55 // Stop does not close the channel, to prevent a read from the channel succeeding
  56 // incorrectly.
  57 //
  58 // To prevent the timer firing after a call to Stop,
  59 // check the return value and drain the channel. For example:
  60 //      if !t.Stop() {
  61 //              <-t.C
  62 //      }
  63 // This cannot be done concurrent to other receives from the Timer's
  64 // channel.
  65 func (t *Timer) Stop() bool {
  66         if t.r.f == nil {
  67                 panic("time: Stop called on uninitialized Timer")
  68         }
  69         return stopTimer(&t.r)
  70 }
  71
  72 // NewTimer creates a new Timer that will send
  73 // the current time on its channel after at least duration d.
  74 func NewTimer(d Duration) *Timer {
  75         c := make(chan Time, 1)
  76         t := &Timer{
  77                 C: c,
  78                 r: runtimeTimer{
  79                         when: when(d),
  80                         f:    sendTime,
  81                         arg:  c,
  82                 },
  83         }
  84         startTimer(&t.r)
  85         return t
  86 }
  87
  88 // Reset changes the timer to expire after duration d.
  89 // It returns true if the timer had been active, false if the timer had
  90 // expired or been stopped.
  91 //
  92 // To reuse an active timer, always call its Stop method first and—if it had
  93 // expired—drain the value from its channel. For example:
  94 //      if !t.Stop() {
  95 //              <-t.C
  96 //      }
  97 //      t.Reset(d)
  98 // This should not be done concurrent to other receives from the Timer's
  99 // channel.
 100 //
 101 // Note that it is not possible to use Reset's return value correctly, as there
 102 // is a race condition between draining the channel and the new timer expiring.
 103 // Reset should always be used in concert with Stop, as described above.
 104 // The return value exists to preserve compatibility with existing programs.
 105 func (t *Timer) Reset(d Duration) bool {
 106         if t.r.f == nil {
 107                 panic("time: Reset called on uninitialized Timer")
 108         }
 109         w := when(d)
 110         active := stopTimer(&t.r)
 111         t.r.when = w
 112         startTimer(&t.r)
 113         return active
 114 }
 115
 116 func sendTime(c interface{}, seq uintptr) {
 117         // Non-blocking send of time on c.
 118         // Used in NewTimer, it cannot block anyway (buffer).
 119         // Used in NewTicker, dropping sends on the floor is
 120         // the desired behavior when the reader gets behind,
 121         // because the sends are periodic.
 122         select {
 123         case c.(chan Time) <- Now():
 124         default:
 125         }
 126 }
 127
 128 // After waits for the duration to elapse and then sends the current time
 129 // on the returned channel.
 130 // It is equivalent to NewTimer(d).C.
 131 // The underlying Timer is not recovered by the garbage collector
 132 // until the timer fires. If efficiency is a concern, use NewTimer
 133 // instead and call Timer.Stop if the timer is no longer needed.
 134 func After(d Duration) <-chan Time {
 135         return NewTimer(d).C
 136 }
 137
 138 // AfterFunc waits for the duration to elapse and then calls f
 139 // in its own goroutine. It returns a Timer that can
 140 // be used to cancel the call using its Stop method.
 141 func AfterFunc(d Duration, f func()) *Timer {
 142         t := &Timer{
 143                 r: runtimeTimer{
 144                         when: when(d),
 145                         f:    goFunc,
 146                         arg:  f,
 147                 },
 148         }
 149         startTimer(&t.r)
 150         return t
 151 }
 152
 153 func goFunc(arg interface{}, seq uintptr) {
 154         go arg.(func())()
 155 }