mirror of
https://github.com/golang/go
synced 2024-11-24 20:20:03 -07:00
508bb17edd
From the beginning of Go, the time package has had a gotcha: if you use a select on <-time.After(1*time.Minute), even if the select finishes immediately because some other case is ready, the underlying timer from time.After keeps running until the minute is over. This pins the timer in the timer heap, which keeps it from being garbage collected and in extreme cases also slows down timer operations. The lack of garbage collection is the more important problem. The docs for After warn against this scenario and suggest using NewTimer with a call to Stop after the select instead, purely to work around this garbage collection problem. Oddly, the docs for NewTimer and NewTicker do not mention this problem, but they have the same issue: they cannot be collected until either they are Stopped or, in the case of Timer, the timer expires. (Tickers repeat, so they never expire.) People have built up a shared knowledge that timers and tickers need to defer t.Stop even though the docs do not mention this (it is somewhat implied by the After docs). This CL fixes the garbage collection problem, so that a timer that is unreferenced can be GC'ed immediately, even if it is still running. The approach is to only insert the timer into the heap when some channel operation is blocked on it; the last channel operation to stop using the timer takes it back out of the heap. When a timer's channel is no longer referenced, there are no channel operations blocked on it, so it's not in the heap, so it can be GC'ed immediately. This CL adds an undocumented GODEBUG asynctimerchan=1 that will disable the change. The documentation happens in the CL 568341. Fixes #8898. Fixes #61542. Change-Id: Ieb303b6de1fb3527d3256135151a9e983f3c27e6 Reviewed-on: https://go-review.googlesource.com/c/go/+/512355 Reviewed-by: Austin Clements <austin@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Russ Cox <rsc@golang.org>
67 lines
2.2 KiB
Go
67 lines
2.2 KiB
Go
// Copyright 2011 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
|
|
|
|
func init() {
|
|
// Force US/Pacific for time zone tests.
|
|
ForceUSPacificForTesting()
|
|
}
|
|
|
|
func initTestingZone() {
|
|
// For hermeticity, use only tzinfo source from the test's GOROOT,
|
|
// not the system sources and not whatever GOROOT may happen to be
|
|
// set in the process's environment (if any).
|
|
// This test runs in GOROOT/src/time, so GOROOT is "../..",
|
|
// but it is theoretically possible
|
|
sources := []string{"../../lib/time/zoneinfo.zip"}
|
|
z, err := loadLocation("America/Los_Angeles", sources)
|
|
if err != nil {
|
|
panic("cannot load America/Los_Angeles for testing: " + err.Error() + "; you may want to use -tags=timetzdata")
|
|
}
|
|
z.name = "Local"
|
|
localLoc = *z
|
|
}
|
|
|
|
var origPlatformZoneSources []string = platformZoneSources
|
|
|
|
func disablePlatformSources() (undo func()) {
|
|
platformZoneSources = nil
|
|
return func() {
|
|
platformZoneSources = origPlatformZoneSources
|
|
}
|
|
}
|
|
|
|
var Interrupt = interrupt
|
|
var DaysIn = daysIn
|
|
|
|
func empty(arg any, seq uintptr, delta int64) {}
|
|
|
|
// Test that a runtimeTimer with a period that would overflow when on
|
|
// expiration does not throw or cause other timers to hang.
|
|
//
|
|
// This test has to be in internal_test.go since it fiddles with
|
|
// unexported data structures.
|
|
func CheckRuntimeTimerPeriodOverflow() {
|
|
// We manually create a runtimeTimer with huge period, but that expires
|
|
// immediately. The public Timer interface would require waiting for
|
|
// the entire period before the first update.
|
|
t := (*Timer)(newTimer(runtimeNano(), 1<<63-1, empty, nil, nil))
|
|
defer t.Stop()
|
|
|
|
// If this test fails, we will either throw (when siftdownTimer detects
|
|
// bad when on update), or other timers will hang (if the timer in a
|
|
// heap is in a bad state). There is no reliable way to test this, but
|
|
// we wait on a short timer here as a smoke test (alternatively, timers
|
|
// in later tests may hang).
|
|
<-After(25 * Millisecond)
|
|
}
|
|
|
|
var (
|
|
MinMonoTime = Time{wall: 1 << 63, ext: -1 << 63, loc: UTC}
|
|
MaxMonoTime = Time{wall: 1 << 63, ext: 1<<63 - 1, loc: UTC}
|
|
|
|
NotMonoNegativeTime = Time{wall: 0, ext: -1<<63 + 50}
|
|
)
|