github.com/theQRL/go-zond@v0.1.1/common/mclock/alarm.go (about) 1 // Copyright 2022 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package mclock 18 19 import ( 20 "time" 21 ) 22 23 // Alarm sends timed notifications on a channel. This is very similar to a regular timer, 24 // but is easier to use in code that needs to re-schedule the same timer over and over. 25 // 26 // When scheduling an Alarm, the channel returned by C() will receive a value no later 27 // than the scheduled time. An Alarm can be reused after it has fired and can also be 28 // canceled by calling Stop. 29 type Alarm struct { 30 ch chan struct{} 31 clock Clock 32 timer Timer 33 deadline AbsTime 34 } 35 36 // NewAlarm creates an Alarm. 37 func NewAlarm(clock Clock) *Alarm { 38 if clock == nil { 39 panic("nil clock") 40 } 41 return &Alarm{ 42 ch: make(chan struct{}, 1), 43 clock: clock, 44 } 45 } 46 47 // C returns the alarm notification channel. This channel remains identical for 48 // the entire lifetime of the alarm, and is never closed. 49 func (e *Alarm) C() <-chan struct{} { 50 return e.ch 51 } 52 53 // Stop cancels the alarm and drains the channel. 54 // This method is not safe for concurrent use. 55 func (e *Alarm) Stop() { 56 // Clear timer. 57 if e.timer != nil { 58 e.timer.Stop() 59 } 60 e.deadline = 0 61 62 // Drain the channel. 63 select { 64 case <-e.ch: 65 default: 66 } 67 } 68 69 // Schedule sets the alarm to fire no later than the given time. If the alarm was already 70 // scheduled but has not fired yet, it may fire earlier than the newly-scheduled time. 71 func (e *Alarm) Schedule(time AbsTime) { 72 now := e.clock.Now() 73 e.schedule(now, time) 74 } 75 76 func (e *Alarm) schedule(now, newDeadline AbsTime) { 77 if e.timer != nil { 78 if e.deadline > now && e.deadline <= newDeadline { 79 // Here, the current timer can be reused because it is already scheduled to 80 // occur earlier than the new deadline. 81 // 82 // The e.deadline > now part of the condition is important. If the old 83 // deadline lies in the past, we assume the timer has already fired and needs 84 // to be rescheduled. 85 return 86 } 87 e.timer.Stop() 88 } 89 90 // Set the timer. 91 d := time.Duration(0) 92 if newDeadline < now { 93 newDeadline = now 94 } else { 95 d = newDeadline.Sub(now) 96 } 97 e.timer = e.clock.AfterFunc(d, e.send) 98 e.deadline = newDeadline 99 } 100 101 func (e *Alarm) send() { 102 select { 103 case e.ch <- struct{}{}: 104 default: 105 } 106 }