时间

time 包提供了测量和显示时间的功能。

Time

Time 表示具有纳秒精度的时间点。

package main

import (
	"fmt"
	"time"
)

func main() {
	// 获取当前时间
	currentTime := time.Now()

	// 格式化并显示时间
	fmt.Println("Current Time:", currentTime.Format("2006-01-02 15:04:05"))

    t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
	fmt.Printf("Go launched at %s\n", t.Local())
}

纪元

程序中的一个常见需求是获取自Unix 纪元（1970年1月1日 UTC 00:00:00）以来的秒数、毫秒数或纳秒数。

package main

import (
	"fmt"
	"time"
)

func main() {
	currentTime := time.Now()
	epochTime := currentTime.Unix()
	fmt.Println("Current Epoch Time:", epochTime)
}

超时

在 Go 中，time.After 函数可用于创建一个通道，在指定的持续时间之后发送当前时间。通常用于实现超时。

package main

import (
	"fmt"
	"time"
)

func main() {
	timeoutDuration := 3 * time.Second

	// 创建一个通道，该通道将在指定的一段时间后接收当前时间
	timeoutChan := time.After(timeoutDuration)

	fmt.Println("Start operation...")

	time.Sleep(2 * time.Second)

	select {
	case <-timeoutChan:
		fmt.Println("Operation timed out!")
	case <-time.After(time.Second):
		fmt.Println("Operation completed successfully.")
	}
}

定时器

time 包提供了 Timer 类型，可用于在指定的时间后执行操作。

package main

import (
	"fmt"
	"time"
)

func main() {
	timeoutDuration := 3 * time.Second

	// 创建一个将在指定的持续时间后触发的定时器
	timer := time.NewTimer(timeoutDuration)

	fmt.Println("Start operation...")

	time.Sleep(2 * time.Second)

	// 等待定时器触发
	<-timer.C

	fmt.Println("Operation timed out!")
}

当你只是想要一个在一段持续时间后发送信号的通道，使用 time.After。 当你需要更多控制，比如在计时器触发之前停止计时器，使用 time.Timer。

周期性定时器

Ticker 类型可用于在周期性时间间隔执行操作。

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建一个每秒钟触发一次的 Ticker
	ticker := time.NewTicker(1 * time.Second)

	fmt.Println("Start operation...")

	for i := 0; i < 5; i++ {
		<-ticker.C

		// 在每个滴答时执行操作
		fmt.Println("Tick", i)
	}

	ticker.Stop()

	fmt.Println("Operation completed successfully.")
}
// => Start operation...
// Tick 0
// Tick 1
// Tick 2
// Tick 3
// Tick 4
// Operation completed successfully.

速率限制

速率限制是一种控制资源利用速率和保持服务质量的重要机制。

Go 提供了 golang.org/x/time/rate 包用于实现速率限制。 或者，开发者可以选择手动使用 time.Ticker 来实现速率限制。

package main

import (
    "fmt"
    "time"
)

func main() {

    requests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        requests <- i
    }
    close(requests)

    limiter := time.Tick(200 * time.Millisecond)

    for req := range requests {
        <-limiter
        fmt.Println("request", req, time.Now())
    }
}
// => 
// request 1 2013-10-07 16:41:15.236641687 +0000 UTC m=+0.200585747
// request 2 2013-10-07 16:41:15.436968762 +0000 UTC m=+0.400912897
// request 3 2013-10-07 16:41:15.636203458 +0000 UTC m=+0.600147531
// request 4 2013-10-07 16:41:15.836366439 +0000 UTC m=+0.800310502
// request 5 2013-10-07 16:41:16.036687838 +0000 UTC m=+1.000631919

代码挑战

写一个周期性间隔执行任务的程序。