[CHG] golang/go#27169

Author: searKing

go/time/timer.go go/time/sleep.go

@@ -2,39 +2,58 @@ package time
 
 import (
 	"time"
-
-	"github.com/searKing/golang/go/sync/atomic"
 )
 
 // https://github.com/golang/go/issues/27169
 // Timer to fix time: Timer.Stop documentation example easily leads to deadlocks
 type Timer struct {
 	*time.Timer
-	chanConsumed atomic.Bool
 }
 
-// saw channel read, must be called after receiving value from timer chan
-// an example case is AfterFunc bellow.
-func (t *Timer) ChanConsumed() {
-	t.chanConsumed.Store(true)
+// Stop prevents the Timer from firing, with the channel drained.
+// Stop ensures the channel is empty after a call to Stop.
+// Stop == std [Stop + drain]
+// It returns true if the call stops the timer, false if the timer has already
+// expired or been stopped.
+// Stop does not close the channel, to prevent a read from the channel succeeding
+// incorrectly.
+func (t *Timer) Stop() bool {
+	if t.Timer == nil {
+		panic("time: Stop called on uninitialized Timer")
+	}
+
+	active := t.Timer.Stop()
+	if !active {
+		// drain the channel, prevents the Timer from blocking on Send to t.C by sendTime, t.C is reused.
+		// The underlying Timer is not recovered by the garbage collector until the timer fires.
+		// consume the channel only once for the channel can be triggered only one time at most before Stop is called.
+	L:
+		for {
+			select {
+			case _, ok := <-t.Timer.C:
+				if !ok {
+					break L
+				}
+			default:
+				break L
+			}
+		}
+	}
+	return active
 }
 
 // Reset changes the timer to expire after duration d.
+// Reset can be invoked anytime, which enhances std time.Reset
+// Reset == std [Stop + drain + Reset]
 // It returns true if the timer had been active, false if the timer had
 // expired or been stopped.
-// Reset can be invoked anytime, which enhances std time.Reset
-// that should be invoked only on stopped or expired timers with drained channels,
 func (t *Timer) Reset(d time.Duration) bool {
-	ret := t.Stop()
-	if !ret && !t.chanConsumed.Load() {
-		// drain the channel, prevents the Timer from blocking on Send to t.C by sendTime, t.C is reused.
-		// The underlying Timer is not recovered by the garbage collector until the timer fires.
-		// consume the channel only once for the channel can be triggered only one time at most before Stop is called.
-		<-t.C
+	if t.Timer == nil {
+		panic("time: Reset called on uninitialized Timer")
 	}
+	active := t.Stop()
 	t.Timer.Reset(d)
-	t.chanConsumed.Store(false)
-	return ret
+	return active
 }
 
 func NewTimer(d time.Duration) *Timer {
@@ -56,7 +75,6 @@ func After(d time.Duration) <-chan time.Time {
 func AfterFunc(d time.Duration, f func()) *Timer {
 	t := &Timer{}
 	t.Timer = time.AfterFunc(d, func() {
-		t.ChanConsumed()
 		f()
 	})
 	return t

go/time/sleep_test.go

@@ -0,0 +1,123 @@
+package time_test
+
+import (
+	"errors"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	time_ "github.com/searKing/golang/go/time"
+)
+
+func benchmark(b *testing.B, bench func(n int)) {
+	// Create equal number of garbage timers on each P before starting
+	// the benchmark.
+	var wg sync.WaitGroup
+	garbageAll := make([][]*time_.Timer, runtime.GOMAXPROCS(0))
+	for i := range garbageAll {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			garbage := make([]*time_.Timer, 1<<15)
+			for j := range garbage {
+				garbage[j] = time_.AfterFunc(time.Hour, nil)
+			}
+			garbageAll[i] = garbage
+		}(i)
+	}
+	wg.Wait()
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			bench(1000)
+		}
+	})
+	b.StopTimer()
+
+	for _, garbage := range garbageAll {
+		for _, t := range garbage {
+			t.Stop()
+		}
+	}
+}
+func BenchmarkReset(b *testing.B) {
+	benchmark(b, func(n int) {
+		t := time_.NewTimer(time.Hour)
+		for i := 0; i < n; i++ {
+			t.Reset(time.Hour)
+		}
+		t.Stop()
+	})
+}
+
+func testReset(d time.Duration) error {
+	t0 := time.NewTimer(2 * d)
+	time.Sleep(d)
+	if !t0.Reset(3 * d) {
+		return errors.New("resetting unfired timer returned false")
+	}
+	time.Sleep(2 * d)
+	select {
+	case <-t0.C:
+		return errors.New("timer fired early")
+	default:
+	}
+	time.Sleep(2 * d)
+	select {
+	case <-t0.C:
+	default:
+		return errors.New("reset timer did not fire")
+	}
+
+	if t0.Reset(50 * time.Millisecond) {
+		return errors.New("resetting expired timer returned true")
+	}
+	return nil
+}
+
+func TestReset(t *testing.T) {
+	// We try to run this test with increasingly larger multiples
+	// until one works so slow, loaded hardware isn't as flaky,
+	// but without slowing down fast machines unnecessarily.
+	const unit = 25 * time.Millisecond
+	tries := []time.Duration{
+		1 * unit,
+		3 * unit,
+		7 * unit,
+		15 * unit,
+	}
+	var err error
+	for _, d := range tries {
+		err = testReset(d)
+		if err == nil {
+			t.Logf("passed using duration %v", d)
+			return
+		}
+	}
+	t.Error(err)
+}
+
+func checkZeroPanicString(t *testing.T) {
+	e := recover()
+	s, _ := e.(string)
+	if want := "called on uninitialized Timer"; !strings.Contains(s, want) {
+		t.Errorf("panic = %v; want substring %q", e, want)
+	}
+}
+
+func TestZeroTimerResetPanics(t *testing.T) {
+	defer checkZeroPanicString(t)
+	var tr time_.Timer
+	tr.Reset(1)
+}
+
+func TestTimer_Reset(t *testing.T) {
+	tr := time_.NewTimer(25 * time.Millisecond)
+	defer func() {
+		tr.Stop()
+	}()
+	<-tr.C
+}