[轉]Golang定時器陷阱

所謂陷阱，就是它不是你認為的那樣，這種認知誤差可能讓你的軟體留下隐藏Bug。剛好Timer就有3個陷阱，我們會講 1)Reset的陷阱和 2)通道的陷阱，3)Stop的陷阱與Reset的陷阱類似，自己探索吧。

Reset的陷阱在哪

​

​Timer.Reset()​

​函數的傳回值是bool類型，我們看一個問題三連：

1. 它的傳回值代表什麼呢？
2. 我們想要的成功是什麼？
3. 失敗是什麼？

• 成功：一段時間之後定時器逾時，收到逾時事件。
• 失敗：成功的反面，我們收不到那個事件。對于失敗，我們應當做些什麼，確定我們的定時器發揮作用。

Reset的傳回值是不是這個意思？

<!--more-->

通過檢視文檔和實作，​

​Timer.Reset()​

​的傳回值并不符合我們的預期，這就是誤差。它的傳回值不代表重設定時器成功或失敗，而是在表達定時器在重設前的狀态：

• 當Timer已經停止或者逾時，傳回false。
• 當定時器未逾時時，傳回true。

是以，當Reset傳回false時，我們并不能認為一段時間之後，逾時不會到來，實際上可能會到來，定時器已經生效了。

跳過陷阱，再遇陷阱

如何跳過前面的陷阱，讓Reset符合我們的預期功能呢？直接忽視Reset的傳回值好了，它不能幫助你達到預期的效果。

真正的陷阱是Timer的通道，它和我們預期的成功、失敗密切相關。我們所期望的定時器設定失敗，通常隻和通道有關：設定定時器前，定時器的通道​

​Timer.C​

​中是否已經有資料。

• 如果有，我們設定的定時器失敗了，我們可能讀到不正确的逾時事件。
• 如果沒有，我們設定的定時器成功了，我們在設定的時間得到逾時事件。

接下來解釋為何失敗隻與通道中是否存在逾時事件有關。

定時器的緩存通道大小隻為1，無法多存放逾時事件，看源碼。

// NewTimer creates a new Timer that will send
// the current time on its channel after at least duration d.
func NewTimer(d Duration) *Timer {
    c := make(chan Time, 1) // 緩存通道大小為1
    t := &Timer{
        C: c,
        r: runtimeTimer{
            when: when(d),
            f:    sendTime,
            arg:  c,
        },
    }
    startTimer(&t.r)
    return t
}      

定時器建立後是單獨運作的，逾時後會向通道寫入資料，你從通道中把資料讀走。目前一次的逾時資料沒有被讀取，而設定了新的定時器，然後去通道讀資料，結果讀到的是上次逾時的逾時事件，看似成功，實則失敗，完全掉入陷阱。

跨越陷阱，確定成功

如果確定​

​Timer.Reset()​

​成功，得到我們想要的結果？​

​Timer.Reset()​

​前清空通道。

• 當業務場景簡單時，沒有必要主動清空通道。比如，處理流程是：設定1次定時器，處理一次定時器，中間無中斷，下次Reset前，通道必然是空的。
• 當業務場景複雜時，不确定通道是否為空，那就主動清除。

// 方法1
if len(Timer.C) > 0{
    <-Timer.C
}
Timer.Reset(time.Second)      

經過的讨論和思考，更加合理的做法還是下面這樣：

// 方法2
if !Timer.Stop() && len(Timer.C) > 0{
    <-Timer.C
}
Timer.Reset(time.Second)      

定時器的運作和​

​len(Timer.C)​

​的判斷是在不同的協程中，當判斷的時候通道大小可能為0，但當執行​

​Reset()​

​的前的這段時間，舊的定時器逾時，通道中存在逾時時間，再執行​

​Reset()​

​也達不到預期的效果。

方法2才是合理的方法。先執行​

​Stop()​

​，可以確定舊定時器已經停止，不會再向通道中寫入逾時事件，就可解決上面的問題。​

​Stop()​

​傳回false并不是代表，通道中一定存在逾時事件，是以還需使用​

​len(Timer.C) > 0​

​進行判斷再決定是否清空通道。

測試代碼

package main

import (
    "fmt"
    "time"
)

// 不同情況下，Timer.Reset()的傳回值
func test1() {
    fmt.Println("第1個測試：Reset傳回值和什麼有關？")
    tm := time.NewTimer(time.Second)
    defer tm.Stop()

    quit := make(chan bool)

    // 退出事件
    go func() {
        time.Sleep(3 * time.Second)
        quit <- true
    }()

    // Timer未逾時，看Reset的傳回值
    if !tm.Reset(time.Second) {
        fmt.Println("未逾時，Reset傳回false")
    } else {
        fmt.Println("未逾時，Reset傳回true")
    }

    // 停止timer
    tm.Stop()
    if !tm.Reset(time.Second) {
        fmt.Println("停止Timer，Reset傳回false")
    } else {
        fmt.Println("停止Timer，Reset傳回true")
    }

    // Timer逾時
    for {
        select {
        case <-quit:
            return

        case <-tm.C:
            if !tm.Reset(time.Second) {
                fmt.Println("逾時，Reset傳回false")
            } else {
                fmt.Println("逾時，Reset傳回true")
            }
        }
    }
}

func test2() {
    fmt.Println("\n第2個測試:逾時後，不讀通道中的事件，可以Reset成功嗎？")
    sm2Start := time.Now()
    tm2 := time.NewTimer(time.Second)
    time.Sleep(2 * time.Second)
    fmt.Printf("Reset前通道中事件的數量:%d\n", len(tm2.C))
    if !tm2.Reset(time.Second) {
        fmt.Println("不讀通道資料，Reset傳回false")
    } else {
        fmt.Println("不讀通道資料，Reset傳回true")
    }
    fmt.Printf("Reset後通道中事件的數量:%d\n", len(tm2.C))

    select {
    case t := <-tm2.C:
        fmt.Printf("tm2開始的時間: %v\n", sm2Start.Unix())
        fmt.Printf("通道中事件的時間：%v\n", t.Unix())
        if t.Sub(sm2Start) <= time.Second+time.Millisecond {
            fmt.Println("通道中的時間是重新設定sm2前的時間，即第一次逾時的時間，是以第二次Reset失敗了")
        }
    }

    fmt.Printf("讀通道後，其中事件的數量:%d\n", len(tm2.C))
    tm2.Reset(time.Second)
    fmt.Printf("再次Reset後，通道中事件的數量:%d\n", len(tm2.C))
    time.Sleep(2 * time.Second)
    fmt.Printf("逾時後通道中事件的數量:%d\n", len(tm2.C))
}

func test3() {
    fmt.Println("\n第3個測試：Reset前清空通道，盡可能通暢")
    smStart := time.Now()
    tm := time.NewTimer(time.Second)
    time.Sleep(2 * time.Second)

    // 停掉定時器再清空
    if !tm.Stop() && len(tm.C) > 0 {
        <-tm.C
    }
    tm.Reset(time.Second)

    // 逾時
    t := <-tm.C
    fmt.Printf("tm開始的時間: %v\n", smStart.Unix())
    fmt.Printf("通道中事件的時間：%v\n", t.Unix())
    if t.Sub(smStart) <= time.Second+time.Millisecond {
        fmt.Println("通道中的時間是重新設定sm前的時間，即第一次逾時的時間，是以第二次Reset失敗了")
    } else {
        fmt.Println("通道中的時間是重新設定sm後的時間，Reset成功了")
    }
}

func main() {
    test1()
    test2()
    test3()
}