Golang并发安全计时器实现技巧

type SafeTimer struct {
    mu    sync.Mutex
    timer *time.Timer
    dur   time.Duration
}
func NewSafeTimer(dur time.Duration) *SafeTimer {
return &SafeTimer{
timer: time.AfterFunc(dur, func() {}),
dur:   dur,
}
}
func (st *SafeTimer) Reset() {
st.mu.Lock()
defer st.mu.Unlock()
if st.timer != nil {
st.timer.Stop()
}
st.timer = time.AfterFunc(st.dur, func() {
// 触发回调逻辑
})
}
func (st *SafeTimer) Stop() bool {
st.mu.Lock()
defer st.mu.Unlock()
if st.timer == nil {
return false
}
return st.timer.Stop()
}

type TimerManager struct {
    resetCh chan bool
    stopCh  chan bool
    done    chan bool
    dur     time.Duration
}
func NewTimerManager(dur time.Duration) *TimerManager {
tm := &TimerManager{
resetCh: make(chan bool),
stopCh:  make(chan bool),
done:    make(chan bool),
dur:     dur,
}
go tm.run()
return tm
}
func (tm TimerManager) run() {
var timer time.Timer
timer = time.AfterFunc(tm.dur, func() {
tm.done <- true
})
for {
    select {
    case <-tm.resetCh:
        if !timer.Stop() {
            select {
            case <-timer.C:
            default:
            }
        }
        timer = time.AfterFunc(tm.dur, func() {
            tm.done <- true
        })
    case <-tm.stopCh:
        if !timer.Stop() {
            select {
            case <-timer.C:
            default:
            }
        }
        return
    }
}
}
func (tm *TimerManager) Reset() {
tm.resetCh <- true
}
func (tm *TimerManager) Stop() {
tm.stopCh <- true
}
func (tm *TimerManager) Done() <-chan bool {
return tm.done
}

func StartSafeTimer(ctx context.Context, dur time.Duration, callback func()) context.CancelFunc {
    timer := time.NewTimer(dur)
    cancel := func() {
        if !timer.Stop() {
            select {
            case <-timer.C:
            default:
            }
        }
    }
go func() {
    select {
    case <-timer.C:
        callback()
    case <-ctx.Done():
        cancel()
    }
}()

return cancel
}