// FnTimer1 Timer的使用用法
func FnTimer1() {
	timer := time.NewTimer(time.Second * 5) //返回生成的timer
	fmt.Printf("timer 的啟動時間為:%v\n", time.Now())

	expire := <-timer.C //注意這個channel是一個容量為1的channel！
	fmt.Printf("timer 的觸發(fā)時間為:%v\n", expire)
}

func FnTimer2() {
	ch1 := make(chan int, 1)
	select {
	case e1 := <-ch1:
		//如果ch1通道成功讀取數(shù)據(jù)，則執(zhí)行該case處理語句
		fmt.Printf("1th case is selected. e1=%v",e1)
	case <- time.After(2 * time.Second): //time.After直接返回生成的timer的channel，所以一般用于超時控制
		fmt.Println("Timed out")
	}
}

func FnTimer3() {
	_ = time.AfterFunc(time.Second*5, func() { //返回的也是timer，不過可以自己傳入函數(shù)進行執(zhí)行
		fmt.Printf("定時器觸發(fā)了,觸發(fā)時間為%v\n", time.Now())
	})

	fmt.Printf("timer 的啟動時間為:%v\n", time.Now())
	time.Sleep(10 * time.Second) // 確保定時器觸發(fā)
}

// FnTicket2 Ticker的正確的使用方法??！
func FnTicket2() {
	ticker := time.NewTicker(1 * time.Second)
	stopTicker := make(chan struct{})
	defer ticker.Stop()
	go func() {
		for {
			select {
			case now := <-ticker.C:
				// do something
				fmt.Printf("ticker 的觸發(fā)時間為:%v\n", now)
			case <-stopTicker:
				fmt.Println("ticker 結束")
				return
			}
		}
	}()

	time.Sleep(4 * time.Second)
	stopTicker <- struct{}{}
}

// Package time knows the layout of this structure.
// If this struct changes, adjust ../time/sleep.go:/runtimeTimer.
type timer struct {
	// If this timer is on a heap, which P's heap it is on.
	// puintptr rather than *p to match uintptr in the versions
	// of this struct defined in other packages.
	pp puintptr //指針，指向持有當前timer的p

	// Timer wakes up at when, and then at when+period, ... (period > 0 only)
	// each time calling f(arg, now) in the timer goroutine, so f must be
	// a well-behaved function and not block.
	//
	// when must be positive on an active timer.
	when   int64              //當前計時器被喚醒的時間；
	period int64              //兩次被喚醒的間隔；
	f      func(any, uintptr) //喚醒時要執(zhí)行的函數(shù)
	arg    any                // 計時器被喚醒時調用 f 傳入的參數(shù)；
	seq    uintptr

	// What to set the when field to in timerModifiedXX status.
	nextwhen int64 //當定時器狀態(tài)變?yōu)閠imerModifiedXX的時，when 字段下一次要設置的值

	// The status field holds one of the values below.
	status uint32 //計時器的狀態(tài)，最重要的字段之一
}

type p struct {
	// Lock for timers. We normally access the timers while running
	// on this P, but the scheduler can also do it from a different P.
	timersLock mutex //操作timers的時候加鎖

	// Actions to take at some time. This is used to implement the
	// standard library's time package.
	// Must hold timersLock to access.
	timers []*timer //timers數(shù)組

	// Number of timers in P's heap.
	// Modified using atomic instructions.
	numTimers uint32 //總timers的數(shù)量

	// Number of timerDeleted timers in P's heap.
	// Modified using atomic instructions.
	deletedTimers uint32 //處于deleted狀態(tài)的timers的數(shù)量

	// Race context used while executing timer functions.
	timerRaceCtx uintptr //競態(tài)檢測相關
}

@startuml

[*] --> timerNoStatus : 運行時創(chuàng)建Timer

timerNoStatus -->timerWaiting : addtimer

timerWaiting -->timerModifying : deltimer、modtimer

timerModifying -->timerDeleted : deltimer

timerModifiedLater -->timerDeleted : deltimer

timerModifiedEarlier -->timerModifying : deltimer


timerDeleted -->timerRemoving : cleantimers、adjusttimers、runtimer

timerRemoving -->timerRemoved : cleantimers、adjusttimers、runtimer

timerModifiedEarlier --> timerMoving : cleantimers、adjusttimers

timerModifiedLater --> timerMoving : cleantimers、adjusttimers

timerMoving --> timerWaiting : cleantimers

timerWaiting --> timerRunning : runtimer

timerRunning --> timerWaiting : runtimer

timerRunning --> timerNoStatus : runtimer

state timerModifiedXX {
  state timerModifiedEarlier {
  }
  state timerModifiedLater {
  }
}

timerModifying --> timerModifiedXX : modtimer
timerModifiedXX --> timerModifying : modtimer

timerNoStatus   --> timerModifying : modtimer
timerModifying --> timerWaiting : modtimer
timerRemoved --> timerModifying : modtimer
timerDeleted    --> timerModifying : modtimer

timerWaiting : 定時器等待觸發(fā)
timerModifying : 定時器狀態(tài)修改的中間態(tài)
timerDeleted : 定時器被標記刪除的狀態(tài)

timerRemoving: 定時器從標記刪除到真正被刪除的中間態(tài)
timerRemoved: 定時器真正被刪除

timerModifiedEarlier: 定時器被修改到了更早的觸發(fā)時間
timerModifiedLater : 定時器被修改到了更晚的觸發(fā)時間

timerMoving: 定時器在堆上的位置正在重新排序
timerRunning: timer正在運行
timerModifiedXX: 定時器在堆上的位置等待重新排序

@enduml

// addtimer:
//   timerNoStatus   -> timerWaiting
//   anything else   -> panic: invalid value
// deltimer:
//   timerWaiting         -> timerModifying -> timerDeleted
//   timerModifiedEarlier -> timerModifying -> timerDeleted
//   timerModifiedLater   -> timerModifying -> timerDeleted
//   timerNoStatus        -> do nothing
//   timerDeleted         -> do nothing
//   timerRemoving        -> do nothing
//   timerRemoved         -> do nothing
//   timerRunning         -> wait until status changes
//   timerMoving          -> wait until status changes
//   timerModifying       -> wait until status changes
// modtimer:
//   timerWaiting    -> timerModifying -> timerModifiedXX
//   timerModifiedXX -> timerModifying -> timerModifiedYY
//   timerNoStatus   -> timerModifying -> timerWaiting
//   timerRemoved    -> timerModifying -> timerWaiting
//   timerDeleted    -> timerModifying -> timerModifiedXX
//   timerRunning    -> wait until status changes
//   timerMoving     -> wait until status changes
//   timerRemoving   -> wait until status changes
//   timerModifying  -> wait until status changes
// cleantimers (looks in P's timer heap):
//   timerDeleted    -> timerRemoving -> timerRemoved
//   timerModifiedXX -> timerMoving -> timerWaiting
// adjusttimers (looks in P's timer heap):
//   timerDeleted    -> timerRemoving -> timerRemoved
//   timerModifiedXX -> timerMoving -> timerWaiting
// runtimer (looks in P's timer heap):
//   timerNoStatus   -> panic: uninitialized timer
//   timerWaiting    -> timerWaiting or
//   timerWaiting    -> timerRunning -> timerNoStatus or
//   timerWaiting    -> timerRunning -> timerWaiting
//   timerModifying  -> wait until status changes
//   timerModifiedXX -> timerMoving -> timerWaiting
//   timerDeleted    -> timerRemoving -> timerRemoved
//   timerRunning    -> panic: concurrent runtimer calls
//   timerRemoved    -> panic: inconsistent timer heap
//   timerRemoving   -> panic: inconsistent timer heap
//   timerMoving     -> panic: inconsistent timer heap

func addtimer(t *timer) {
	 // xxx
	if t.status != timerNoStatus {
		throw("addtimer called with initialized timer")
	}
	t.status = timerWaiting

	when := t.when

	// Disable preemption while using pp to avoid changing another P's heap.
	mp := acquirem()

	pp := getg().m.p.ptr()
	lock(&pp.timersLock)
	cleantimers(pp)       //嘗試清除timers堆中堆頭的元素，以加速定時器添加
	doaddtimer(pp, t)
	unlock(&pp.timersLock)

	wakeNetPoller(when)

	releasem(mp)
}

// deltimer deletes the timer t. It may be on some other P, so we can't
// actually remove it from the timers heap. We can only mark it as deleted.
// It will be removed in due course by the P whose heap it is on.
// Reports whether the timer was removed before it was run.
func deltimer(t *timer) bool {
	for {
		switch s := atomic.Load(&t.status); s {
		case timerWaiting, timerModifiedLater:
			// Prevent preemption while the timer is in timerModifying.
			// This could lead to a self-deadlock. See #38070.
			mp := acquirem()
			if atomic.Cas(&t.status, s, timerModifying) {
				// 必須要先拿到tpp，因為當狀態(tài)設置為timerDeleted之后，timer就有可能被清除（cleantimers函數(shù)），就拿不到tpp了
				tpp := t.pp.ptr()
				if !atomic.Cas(&t.status, timerModifying, timerDeleted) {
					badTimer()
				}
				releasem(mp)
				atomic.Xadd(&tpp.deletedTimers, 1)
				// Timer was not yet run.
				return true
			} else {
				releasem(mp)
			}
		case timerModifiedEarlier:
			// 這里和上面case的代碼在源碼中除了注釋少一點其他一模一樣，暫不清楚為什么
			mp := acquirem()
			if atomic.Cas(&t.status, s, timerModifying) {
				tpp := t.pp.ptr() //先拿到tpp，原理同上
				if !atomic.Cas(&t.status, timerModifying, timerDeleted) {
					badTimer()
				}
				releasem(mp)
				atomic.Xadd(&tpp.deletedTimers, 1)
				// Timer was not yet run.
				return true
			} else {
				releasem(mp)
			}
		case timerDeleted, timerRemoving, timerRemoved:
			// Timer was already run.
			return false
		case timerRunning, timerMoving:
			// The timer is being run or moved, by a different P.
			// Wait for it to complete.
			osyield()
		case timerNoStatus:
			// Removing timer that was never added or
			// has already been run. Also see issue 21874.
			return false
		case timerModifying:
			// Simultaneous calls to deltimer and modtimer.
			// Wait for the other call to complete.
			osyield()
		default:
			badTimer()
		}
	}
}

//   timerWaiting    -> timerModifying -> timerModifiedXX
//   timerModifiedXX -> timerModifying -> timerModifiedYY
//   timerNoStatus   -> timerModifying -> timerWaiting
//   timerRemoved    -> timerModifying -> timerWaiting
//   timerDeleted    -> timerModifying -> timerModifiedXX
//   timerRunning    -> wait until status changes
//   timerMoving     -> wait until status changes
//   timerRemoving   -> wait until status changes
//   timerModifying  -> wait until status changes

// resettimer resets the time when a timer should fire.
// If used for an inactive timer, the timer will become active.
// This should be called instead of addtimer if the timer value has been,
// or may have been, used previously.
// Reports whether the timer was modified before it was run.
func resettimer(t *timer, when int64) bool {
	return modtimer(t, when, t.period, t.f, t.arg, t.seq)
}

// cleantimers cleans up the head of the timer queue. This speeds up
// programs that create and delete timers; leaving them in the heap
// slows down addtimer. Reports whether no timer problems were found.
// The caller must have locked the timers for pp.
func cleantimers(pp *p) {
	gp := getg()
	for {
		if len(pp.timers) == 0 {
			return
		}

		t := pp.timers[0]

		switch s := atomic.Load(&t.status); s {
		case timerDeleted: //被標記刪除，現(xiàn)在正式移除
			if !atomic.Cas(&t.status, s, timerRemoving) {
				continue
			}
			dodeltimer0(pp)
			if !atomic.Cas(&t.status, timerRemoving, timerRemoved) {
				badTimer()
			}
			atomic.Xadd(&pp.deletedTimers, -1)
		case timerModifiedEarlier, timerModifiedLater: //定時器被調整，移動其到正確的位置
			if !atomic.Cas(&t.status, s, timerMoving) {
				continue
			}
			// Now we can change the when field.
			t.when = t.nextwhen
			// Move t to the right position.
			dodeltimer0(pp)
			doaddtimer(pp, t)
			if !atomic.Cas(&t.status, timerMoving, timerWaiting) {
				badTimer()
			}
		default:
			// Head of timers does not need adjustment.
			return
		}
	}
}

// adjusttimers (looks in P's timer heap):
//   timerDeleted    -> timerRemoving -> timerRemoved
//   timerModifiedXX -> timerMoving -> timerWaiting

// runtimer (looks in P's timer heap):
//   timerNoStatus   -> panic: uninitialized timer
//   timerWaiting    -> timerWaiting or
//   timerWaiting    -> timerRunning -> timerNoStatus or
//   timerWaiting    -> timerRunning -> timerWaiting
//   timerModifying  -> wait until status changes
//   timerModifiedXX -> timerMoving -> timerWaiting
//   timerDeleted    -> timerRemoving -> timerRemoved
//   timerRunning    -> panic: concurrent runtimer calls
//   timerRemoved    -> panic: inconsistent timer heap
//   timerRemoving   -> panic: inconsistent timer heap
//   timerMoving     -> panic: inconsistent timer heap

if len(pp.timers) > 0 {
		adjusttimers(pp, now)
		for len(pp.timers) > 0 {
			// Note that runtimer may temporarily unlock
			// pp.timersLock.
			if tw := runtimer(pp, now); tw != 0 {
				if tw > 0 {
					pollUntil = tw
				}
				break
			}
			ran = true
		}
}

// checkTimers runs any timers for the P that are ready.
// If now is not 0 it is the current time.
// It returns the passed time or the current time if now was passed as 0.
// and the time when the next timer should run or 0 if there is no next timer,
// and reports whether it ran any timers.
// If the time when the next timer should run is not 0,
// it is always larger than the returned time.
// We pass now in and out to avoid extra calls of nanotime.
//go:yeswritebarrierrec
func checkTimers(pp *p, now int64) (rnow, pollUntil int64, ran bool) {
	// If it's not yet time for the first timer, or the first adjusted
	// timer, then there is nothing to do.
	next := int64(atomic.Load64(&pp.timer0When))
	nextAdj := int64(atomic.Load64(&pp.timerModifiedEarliest))
	if next == 0 || (nextAdj != 0 && nextAdj < next) {
		next = nextAdj
	}

	if next == 0 {
		// No timers to run or adjust.
		return now, 0, false
	}

	if now == 0 {
		now = nanotime()
	}
	if now < next {
		// Next timer is not ready to run, but keep going
		// if we would clear deleted timers.
		// This corresponds to the condition below where
		// we decide whether to call clearDeletedTimers.
		//	當前并沒有到觸發(fā)時間，這個檢查的目的就是為了查看位于deletedTimers狀態(tài)的 定時器 的比例，如果比例過大，就要清理
        // 	清理就是調用clearDeletedTimers函數(shù)。
		if pp != getg().m.p.ptr() || int(atomic.Load(&pp.deletedTimers)) <= int(atomic.Load(&pp.numTimers)/4) {
			return now, next, false
		}
	}

	lock(&pp.timersLock)

	if len(pp.timers) > 0 {
		adjusttimers(pp, now)  //上面生成的now會傳下來，因此不用擔心函數(shù)執(zhí)行導致的時間流逝
		for len(pp.timers) > 0 {
			// Note that runtimer may temporarily unlock
			// pp.timersLock.
			if tw := runtimer(pp, now); tw != 0 { //上面生成的now會傳下來，因此不用擔心函數(shù)執(zhí)行導致的時間流逝
				if tw > 0 {
					pollUntil = tw
				}
				break
			}
			ran = true
		}
	}

	// If this is the local P, and there are a lot of deleted timers,
	// clear them out. We only do this for the local P to reduce
	// lock contention on timersLock.
	//如果運行當前goroutine的p是持有timers數(shù)組的p 且 處于deletedTimers狀態(tài)的定時器 比例超過1/4，就清理掉這部分的定時器。
	if pp == getg().m.p.ptr() && int(atomic.Load(&pp.deletedTimers)) > len(pp.timers)/4 {
		clearDeletedTimers(pp)
	}

	unlock(&pp.timersLock)

	return now, pollUntil, ran
}

// This is the only function that walks through the entire timer heap,
// other than moveTimers which only runs when the world is stopped.
func clearDeletedTimers(pp *p) {

// Active timers live in heaps attached to P, in the timers field.
// Inactive timers live there too temporarily, until they are removed.

// Package time knows the layout of this structure.
// If this struct changes, adjust ../time/sleep.go:/runtimeTimer.
// For GOOS=nacl, package syscall knows the layout of this structure.
// If this struct changes, adjust ../syscall/net_nacl.go:/runtimeTimer.
type timer struct {
	i int // heap index

	// Timer wakes up at when, and then at when+period, ... (period > 0 only)
	// each time calling f(arg, now) in the timer goroutine, so f must be
	// a well-behaved function and not block.
	when   int64                      //當前計時器被喚醒的時間
	period int64                      //兩次被喚醒的間隔；
	f      func(interface{}, uintptr) //每當計時器被喚醒時都會調用的函數(shù)；
	arg    interface{}                //計時器被喚醒時調用 f 傳入的參數(shù)；
	seq    uintptr
}

// Interface to timers implemented in package runtime.
// Must be in sync with ../runtime/time.go:/^type timer
type runtimeTimer struct {
	i      int
	when   int64
	period int64
	f      func(interface{}, uintptr) // NOTE: must not be closure
	arg    interface{}
	seq    uintptr
}

	// Disable preemption while using pp to avoid changing another P's heap.
	mp := acquirem()

	pp := getg().m.p.ptr()
	lock(&pp.timersLock)
	cleantimers(pp)
	doaddtimer(pp, t)
	unlock(&pp.timersLock)

	wakeNetPoller(when)

	releasem(mp)

// The timer is in some other P's heap, so we can't change
		// the when field. If we did, the other P's heap would
		// be out of order. So we put the new when value in the
		// nextwhen field, and let the other P set the when field
		// when it is prepared to resort the heap.

if !atomic.Cas(&t.status, s, timerMoving) {
	continue //continue用于等待重試
}

for {
		if t.status == s{ //雙重校驗，延遲加鎖
			t.mu.Lock() // 鎖定
			if t.status == s {
				t.status = timerMoving // 修改狀態(tài)
				t.mu.Unlock()           // 釋放鎖
				break                    // 修改成功，退出
			}
			t.mu.Unlock() // 如果沒有修改成功，解鎖
		}
		// 繼續(xù)等待重試
	}

func addtimer(t *timer) {
	// when must be positive. A negative value will cause runtimer to
	// overflow during its delta calculation and never expire other runtime
	// timers. Zero will cause checkTimers to fail to notice the timer.
	if t.when <= 0 {
		throw("timer when must be positive")
	}
	if t.period < 0 {
		throw("timer period must be non-negative")
	}
	if t.status != timerNoStatus {
		throw("addtimer called with initialized timer")
	}
xxx
}

// startTimer adds t to the timer heap.
//
//go:linkname startTimer time.startTimer
func startTimer(t *timer) {
	if raceenabled {
		racerelease(unsafe.Pointer(t))
	}
	addtimer(t)
}

// updateTimerModifiedEarliest updates the recorded nextwhen field of the
// earlier timerModifiedEarier value.
// The timers for pp will not be locked.
func updateTimerModifiedEarliest(pp *p, nextwhen int64) {
	for {
		old := atomic.Load64(&pp.timerModifiedEarliest)
		if old != 0 && int64(old) < nextwhen {
			return
		}
		if atomic.Cas64(&pp.timerModifiedEarliest, old, uint64(nextwhen)) {
			return
		}
	}
}

// doaddtimer adds t to the current P's heap.
// The caller must have locked the timers for pp.   //注釋說明，這個函數(shù)必須鎖定之后才能進入
func doaddtimer(pp *p, t *timer) {

xxx
}