Run Format

Source file src/pkg/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	func nano() int64 {
    12		sec, nsec := now()
    13		return sec*1e9 + int64(nsec)
    14	}
    15	
    16	// Interface to timers implemented in package runtime.
    17	// Must be in sync with ../runtime/runtime.h:/^struct.Timer$
    18	type runtimeTimer struct {
    19		i      int32
    20		when   int64
    21		period int64
    22		f      func(int64, interface{}) // NOTE: must not be closure
    23		arg    interface{}
    24	}
    25	
    26	// when is a helper function for setting the 'when' field of a runtimeTimer.
    27	// It returns what the time will be, in nanoseconds, Duration d in the future.
    28	// If d is negative, it is ignored.  If the returned value would be less than
    29	// zero because of an overflow, MaxInt64 is returned.
    30	func when(d Duration) int64 {
    31		if d <= 0 {
    32			return nano()
    33		}
    34		t := nano() + int64(d)
    35		if t < 0 {
    36			t = 1<<63 - 1 // math.MaxInt64
    37		}
    38		return t
    39	}
    40	
    41	func startTimer(*runtimeTimer)
    42	func stopTimer(*runtimeTimer) bool
    43	
    44	// The Timer type represents a single event.
    45	// When the Timer expires, the current time will be sent on C,
    46	// unless the Timer was created by 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	func (t *Timer) Stop() bool {
    58		return stopTimer(&t.r)
    59	}
    60	
    61	// NewTimer creates a new Timer that will send
    62	// the current time on its channel after at least duration d.
    63	func NewTimer(d Duration) *Timer {
    64		c := make(chan Time, 1)
    65		t := &Timer{
    66			C: c,
    67			r: runtimeTimer{
    68				when: when(d),
    69				f:    sendTime,
    70				arg:  c,
    71			},
    72		}
    73		startTimer(&t.r)
    74		return t
    75	}
    76	
    77	// Reset changes the timer to expire after duration d.
    78	// It returns true if the timer had been active, false if the timer had
    79	// expired or been stopped.
    80	func (t *Timer) Reset(d Duration) bool {
    81		w := when(d)
    82		active := stopTimer(&t.r)
    83		t.r.when = w
    84		startTimer(&t.r)
    85		return active
    86	}
    87	
    88	func sendTime(now int64, c interface{}) {
    89		// Non-blocking send of time on c.
    90		// Used in NewTimer, it cannot block anyway (buffer).
    91		// Used in NewTicker, dropping sends on the floor is
    92		// the desired behavior when the reader gets behind,
    93		// because the sends are periodic.
    94		select {
    95		case c.(chan Time) <- Unix(0, now):
    96		default:
    97		}
    98	}
    99	
   100	// After waits for the duration to elapse and then sends the current time
   101	// on the returned channel.
   102	// It is equivalent to NewTimer(d).C.
   103	func After(d Duration) <-chan Time {
   104		return NewTimer(d).C
   105	}
   106	
   107	// AfterFunc waits for the duration to elapse and then calls f
   108	// in its own goroutine. It returns a Timer that can
   109	// be used to cancel the call using its Stop method.
   110	func AfterFunc(d Duration, f func()) *Timer {
   111		t := &Timer{
   112			r: runtimeTimer{
   113				when: when(d),
   114				f:    goFunc,
   115				arg:  f,
   116			},
   117		}
   118		startTimer(&t.r)
   119		return t
   120	}
   121	
   122	func goFunc(now int64, arg interface{}) {
   123		go arg.(func())()
   124	}

View as plain text