go語言標準庫裏的定時器使用場景

(1)time.NewTimer，time.NewTicker，time.Tick的使用以下：

package main
 
import (
    "errors"
    "fmt"
    "golang.org/x/sync/errgroup"
    "time"
)
 
/**
* ticker只要定義完成，今後刻開始計時，不須要任何其餘的操做，每隔固定時間都會觸發。
* timer定時器，是到固定時間後值只會執行一次
* 若是timer定時器要每隔間隔的時間執行，實現ticker的效果，使用 func (t *Timer) Reset(d Duration) bool
 */
func main() {
    var g errgroup.Group
 
    g.Go(func() error {
        timer := time.NewTimer(1 * time.Second)
 
        for {
            select {
            case <-timer.C:
                println("1_Tokyo_NewYork_London")
                timer.Reset(1 * time.Second)
                // 若要中止定時器就使用以下代碼，這樣會釋放資源
                // timer.Stop()
            }
            // break
        }
 
        return nil
    })
 
    g.Go(func() error {
        ticker := time.NewTicker(1 * time.Second)
 
        for {
            select {
            case <-ticker.C:
                println("2_NewYork_London_Tokyo")
                // 若要中止定時器就使用以下代碼，這樣會釋放資源
                // ticker.Stop()
            }
            // break
        }
 
        return errors.New("sgdagf")
    })
    // 上一個協程實現的功能同樣的，但這time.Tick沒法中止，也就是沒法釋放資源！
    g.Go(func() error {
        for {
            select {
            case <-time.Tick(1 * time.Second):
                println("3_Singapore_London_Tokyo")
            }
 
            // fmt.Println(<-time.Tick(2 * time.Second))
        }
    })
 
    if err := g.Wait(); err != nil {
        fmt.Println("Err:",err)
    } else {
        println("finish")
    }
}

(2)time.AfterFunc使用以下：

package main
 
import "time"
 
func main() {
    f := func() { println("Tokyo_London_NewYork") }
    // AfterFunc的內部又啓動了一個協程，且這個定時器到了定時時間後，只會執行一次！
    time.AfterFunc(2*time.Second, f)
    time.Sleep(5 * time.Second)
}

下面這個狀況會發生死鎖！

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    fmt.Println(time.Now())
    f := func() { println("Tokyo_London_NewYork") }
    // 執行下面的代碼，會發生死鎖！
    fmt.Println(<-time.AfterFunc(2*time.Second, f).C)
}

(3)time.After使用以下：

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    fmt.Println("3 second before:",time.Now())
    // After函數到了定時時間後只有執行一次!而且返回過了定時時間後的當前時間！
    fmt.Println("3 second after:",    <-time.After(3*time.Second))
}