时间问题总比看起来更复杂
业务代码里到处都有时间：用户注册时间、订单过期时间、活动开始时间、接口超时、定时任务、缓存有效期、日志时间戳。刚开始你可能只会用 time.Now()，但很快会遇到格式化、解析、时区和定时器。时间处理一旦写错，问题往往很隐蔽：本地正常，线上差 8 小时；今天正常，月底出错；测试偶尔超时，查不出原因。
Go 的 time 包设计得很完整。它有 time.Time 表示时间点，time.Duration 表示时间长度，time.Location 表示时区，Timer 和 Ticker 处理定时。掌握这些基本概念，就能覆盖大多数入门和中小项目需求。
这篇文章会用订单过期、日志格式化、活动时间判断和定时任务做例子，讲清楚 Go 时间处理的常见写法。
time.Time 表示一个时间点
当前时间：
now := time.Now()
fmt.Println(now)
获取 Unix 时间戳：
fmt.Println(now.Unix())
fmt.Println(now.UnixMilli())
创建指定时间：
start := time.Date(2020, 3, 11, 10, 0, 0, 0, time.Local)
fmt.Println(start)
time.Date 的参数分别是年、月、日、时、分、秒、纳秒和时区。time.Local 表示本地时区。服务端程序最好明确时区，不要让不同机器的本地配置影响业务。
计算时间差：
deadline := now.Add(30 * time.Minute)
fmt.Println(deadline.Sub(now))
Add 加上一段时间，Sub 计算两个时间点之间的差，返回 time.Duration。
Duration 表示时间长度
time.Duration 本质是纳秒数量，但你很少直接写数字，而是用常量组合：
timeout := 3 * time.Second
cacheTTL := 15 * time.Minute
retention := 7 * 24 * time.Hour
不要写：
timeout := 3000
这完全看不出单位。Go 的时间常量让代码自解释。
业务例子：订单 30 分钟内未支付就过期。
type Order struct {
ID int64
CreatedAt time.Time
Paid bool
}
func (o Order) Expired(now time.Time) bool {
if o.Paid {
return false
}
return now.Sub(o.CreatedAt) > 30*time.Minute
}
注意函数接收 now time.Time，而不是内部直接调用 time.Now()。这样测试更容易：
created := time.Date(2020, 3, 11, 10, 0, 0, 0, time.UTC)
order := Order{CreatedAt: created}
if !order.Expired(created.Add(31 * time.Minute)) {
t.Fatal("order should be expired")
}
把当前时间作为参数传入，是时间相关代码很实用的测试技巧。
Go 的时间格式化很特别
Go 格式化时间不用 YYYY-MM-DD，而是用一个固定参考时间：
formatted := now.Format("2006-01-02 15:04:05")
fmt.Println(formatted)
这个参考时间是：
Mon Jan 2 15:04:05 MST 2006
你可以把它记成 2006-01-02 15:04:05。虽然第一次看很怪，但用久了会发现它避免了 %Y、%m、%d 这类占位符记忆。
解析时间：
value := "2020-03-11 10:30:00"
t, err := time.ParseInLocation("2006-01-02 15:04:05", value, time.Local)
if err != nil {
fmt.Println("parse time:", err)
return
}
fmt.Println(t)
time.Parse 默认按 UTC 解析没有时区的信息。处理本地业务时间时，更常用 time.ParseInLocation，明确告诉它按哪个时区理解。
常见日期格式：
const dateLayout = "2006-01-02"
const dateTimeLayout = "2006-01-02 15:04:05"
把 layout 定义成常量，可以避免到处手写。
时区要显式
加载时区：
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
return err
}
解析上海时间：
t, err := time.ParseInLocation("2006-01-02 15:04:05", "2020-03-11 10:00:00", loc)
转换到 UTC：
fmt.Println(t.UTC())
很多系统会选择“存储用 UTC，展示按用户时区”。这是一条很稳的经验。数据库里存 UTC，可以减少跨地区和夏令时问题；展示时再转换成用户所在时区。
不要随便把时间格式化成字符串后再比较：
if start.Format(dateTimeLayout) < end.Format(dateTimeLayout) {
}
应该直接比较 time.Time：
if start.Before(end) {
}
时间类型已经知道如何比较，不需要绕成字符串。
Timer 和 Ticker
time.Timer 表示一次性定时：
timer := time.NewTimer(2 * time.Second)
<-timer.C
fmt.Println("time is up")
更常见的简单写法：
<-time.After(2 * time.Second)
time.After 会返回一个 channel，到时间后收到值。它适合简单超时，但在循环里大量使用时要注意资源。复杂场景用 Timer 更可控。
time.Ticker 表示周期性触发：
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()
for i := 0; i < 3; i++ {
<-ticker.C
fmt.Println("tick", i)
}
一定要 Stop，否则 ticker 会继续占用资源。
定时任务常见结构：
func runEvery(ctx context.Context, interval time.Duration, job func()) {
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
job()
case <-ctx.Done():
return
}
}
}
这段代码有退出路径。服务停止时取消 context，定时任务就能结束。不要写一个永远没有取消机制的 goroutine。
用时间控制外部调用超时
HTTP 客户端可以设置超时：
client := &http.Client{
Timeout: 3 * time.Second,
}
resp, err := client.Get("https://example.com")
if err != nil {
return err
}
defer resp.Body.Close()
更灵活的是使用 context：
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://example.com", nil)
if err != nil {
return err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
服务端代码里通常使用请求自带的 context：
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
defer cancel()
这样客户端断开、服务端超时和内部调用超时都能沿着 context 传播。
小结
Go 时间处理的几个核心概念要分清：time.Time 是时间点，time.Duration 是时间长度，time.Location 是时区，Timer 是一次性定时，Ticker 是周期触发。格式化和解析使用固定参考时间 2006-01-02 15:04:05，不要套用其他语言的格式占位符。
真实业务里，时间代码要特别重视可测试性和时区。需要判断当前时间时，优先把 now 作为参数传入；存储时间尽量用 UTC，展示时再转时区；定时器和 ticker 要有停止机制；外部调用要设置超时。
时间问题很少在 happy path 暴露，通常在部署环境、跨时区、月底和高并发时出现。入门阶段把这些基本习惯养好，后面会少踩很多坑。
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。