package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now() // 獲取本地時區(qū)當(dāng)前時間，包含完整時區(qū)信息
    fmt.Printf("當(dāng)前時間（本地時區(qū)）：%v\n", now)
    fmt.Printf("當(dāng)前時間（UTC時區(qū)）：%v\n", now.In(time.UTC))
    fmt.Printf("秒級時間戳：%d\n", now.Unix())
    fmt.Printf("納秒級時間戳：%d\n", now.UnixNano())
    fmt.Printf("是否為零時間：%v\n", time.Time{}.IsZero())
    // 時間截斷至小時（分、秒、納秒歸零）
    truncatedHour := now.Truncate(time.Hour)
    fmt.Printf("截斷至小時：%v\n", truncatedHour)
}

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    // 1. TTL轉(zhuǎn)時間：計算緩存過期時間（TTL=30分鐘）
    cacheTTL := 30 * time.Minute
    cacheExpire := now.Add(cacheTTL)
    fmt.Printf("緩存過期時間：%v\n", cacheExpire.Format("2006-01-02 15:04:05"))
    // 2. 時間轉(zhuǎn)TTL：計算剩余存活時間
    remainingTTL := cacheExpire.Sub(now)
    fmt.Printf("緩存剩余TTL：%v\n", remainingTTL)
    // 3. 有效性校驗：避免負(fù)TTL導(dǎo)致邏輯異常
    invalidTime := now.Add(-10 * time.Minute) // 過去的時間
    if !invalidTime.After(now) {
        fmt.Println("目標(biāo)時間已過期，TTL為負(fù)")
        return
    }
}

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    // 1. 時間格式化（Time → 字符串）
    layout1 := "2006-01-02 15:04:05"
    fmt.Printf("標(biāo)準(zhǔn)格式：%v\n", now.Format(layout1)) // 2026-01-28 14:30:00
    layout2 := "2006年01月02日 15時04分05秒 時區(qū)：Z07:00"
    fmt.Printf("帶時區(qū)格式：%v\n", now.Format(layout2)) // 2026年01月28日 14時30分00秒 時區(qū)：+08:00
    layout3 := "01/02/2006 3:04 PM"
    fmt.Printf("12小時制格式：%v\n", now.Format(layout3)) // 01/28/2006 2:30 PM
    // 2. 時間解析（字符串 → Time）
    strTime := "2026-03-10 14:30:00"
    // Parse默認(rèn)解析為UTC時區(qū)
    utcTime, err := time.Parse(layout1, strTime)
    if err != nil {
        fmt.Printf("解析失?。?v\n", err)
        return
    }
    fmt.Printf("解析結(jié)果（UTC）：%v\n", utcTime)
    // 解析為本地時區(qū)（推薦，適配業(yè)務(wù)場景）
    localTime, err := time.ParseInLocation(layout1, strTime, time.Local)
    if err != nil {
        fmt.Printf("本地時區(qū)解析失?。?v\n", err)
        return
    }
    fmt.Printf("解析結(jié)果（本地）：%v\n", localTime)
}

package main
import (
    "fmt"
    "time"
)
func main() {
    // 獲取上海時區(qū)（Asia/Shanghai，UTC+8）
    shLoc, err := time.LoadLocation("Asia/Shanghai")
    if err != nil {
        fmt.Printf("加載上海時區(qū)失敗：%v\n", err)
        return
    }
    shTime := time.Now().In(shLoc)
    fmt.Printf("上海時間：%v\n", shTime.Format("2006-01-02 15:04:05"))
    // 轉(zhuǎn)換為紐約時間（America/New_York，UTC-5/UTC-4，自動適配夏令時）
    nyLoc, err := time.LoadLocation("America/New_York")
    if err != nil {
        fmt.Printf("加載紐約時區(qū)失敗：%v\n", err)
        return
    }
    nyTime := shTime.In(nyLoc)
    fmt.Printf("紐約時間：%v\n", nyTime.Format("2006-01-02 15:04:05"))
}

package main
import (
    "fmt"
    "time"
)
func main() {
    // 場景1：延遲1秒執(zhí)行任務(wù)
    timer1 := time.NewTimer(1 * time.Second)
    go func() {
        <-timer1.C // 阻塞等待定時器觸發(fā)（通道接收時間）
        fmt.Println("1秒后執(zhí)行單次任務(wù)")
    }()
    time.Sleep(1500 * time.Millisecond) // 等待任務(wù)執(zhí)行完成
    // 場景2：停止定時器（避免未觸發(fā)的定時器占用資源）
    timer2 := time.NewTimer(2 * time.Second)
    go func() {
        <-timer2.C
        fmt.Println("該任務(wù)不會執(zhí)行")
    }()
    stopped := timer2.Stop()
    if stopped {
        fmt.Println("定時器已成功停止")
    }
    // 場景3：重置定時器（修改觸發(fā)時間）
    timer3 := time.NewTimer(3 * time.Second)
    timer3.Reset(1 * time.Second) // 重置為1秒后觸發(fā)
    <-timer3.C
    fmt.Println("定時器重置后，1秒觸發(fā)")
}

package main
import (
    "fmt"
    "time"
)
func main() {
    // 創(chuàng)建每秒觸發(fā)一次的定時器
    ticker := time.NewTicker(1 * time.Second)
    done := make(chan struct{}) // 用于控制任務(wù)停止的信號通道
    go func() {
        for {
            select {
            case <-done:
                ticker.Stop() // 停止定時器，釋放資源
                fmt.Println("周期性任務(wù)已停止")
                return
            case t := <-ticker.C:
                fmt.Printf("周期性任務(wù)執(zhí)行：%v\n", t.Format("15:04:05"))
            }
        }
    }()
    // 運行5秒后停止任務(wù)
    time.Sleep(5 * time.Second)
    close(done) // 關(guān)閉通道，發(fā)送停止信號
    time.Sleep(100 * time.Millisecond) // 等待goroutine退出
}

package main
import (
    "context"
    "fmt"
    "time"
)
// 模擬耗時接口請求（隨機(jī)耗時500-1200毫秒）
func fetchData(ctx context.Context, url string) (string, error) {
    delay := time.Duration(500 + time.Now().UnixNano()%700) * time.Millisecond
    select {
    case <-time.After(delay):
        // 任務(wù)正常完成，返回結(jié)果
        return fmt.Sprintf("成功獲取[%s]的核心數(shù)據(jù)", url), nil
    case <-ctx.Done():
        // 感知超時/取消信號，釋放資源并返回錯誤
        return "", fmt.Errorf("請求[%s]失?。?v", url, ctx.Err())
    }
}
func main() {
    // 創(chuàng)建帶1秒超時的Context（父Context為背景Context）
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel() // 確保函數(shù)退出時釋放Context資源，避免泄漏
    // 啟動goroutine執(zhí)行請求任務(wù)
    resultChan := make(chan string)
    errChan := make(chan error)
    go func() {
        res, err := fetchData(ctx, "https://example.com/api")
        if err != nil {
            errChan <- err
            return
        }
        resultChan <- res
    }()
    // 等待結(jié)果或超時
    select {
    case res := <-resultChan:
        fmt.Printf("任務(wù)成功：%v\n", res)
    case err := <-errChan:
        fmt.Printf("任務(wù)失敗：%v\n", err) // 超時會打?。赫埱笫。篶ontext deadline exceeded
    }
}

package main
import (
    "fmt"
    "time"
)
// 模擬實際接口請求，可能返回錯誤
func requestAPI(url string) (string, error) {
    // 模擬接口耗時（100-1200毫秒）
    delay := time.Duration(100 + time.Now().UnixNano()%1100) * time.Millisecond
    time.Sleep(delay)
    // 模擬接口異常（耗時超過800毫秒視為超時錯誤）
    if delay > 800*time.Millisecond {
        return "", fmt.Errorf("接口響應(yīng)超時（耗時：%v）", delay)
    }
    return fmt.Sprintf("請求[%s]成功，返回數(shù)據(jù)長度：1024", url), nil
}
// 帶超時控制的接口請求封裝
func requestWithTimeout(url string, timeout time.Duration) (string, error, time.Duration) {
    start := time.Now()
    ch := make(chan string)
    errCh := make(chan error)
    // 啟動goroutine執(zhí)行接口請求
    go func() {
        res, err := requestAPI(url)
        if err != nil {
            errCh <- err
            return
        }
        ch <- res
    }()
    // 等待結(jié)果、異?；虺瑫r
    select {
    case res := <-ch:
        cost := time.Since(start)
        return res, nil, cost
    case err := <-errCh:
        cost := time.Since(start)
        return "", err, cost
    case <-time.After(timeout):
        cost := time.Since(start)
        return "", fmt.Errorf("請求超時（設(shè)定超時時間：%v）", timeout), cost
    }
}
func main() {
    url := "https://example.com/user/api"
    timeout := 800 * time.Millisecond
    res, err, cost := requestWithTimeout(url, timeout)
    if err != nil {
        fmt.Printf("請求失敗：%v，總耗時：%v\n", err, cost)
        return
    }
    fmt.Printf("請求成功：%v，總耗時：%v\n", res, cost)
}

package main
import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    fmt.Printf("當(dāng)前時間：%v\n", now.Format("2006-01-02 15:04:05"))
    // 1. 獲取明天零點（當(dāng)前時間+1天，再截斷至天精度）
    tomorrowZero := now.AddDate(0, 0, 1).Truncate(24 * time.Hour)
    fmt.Printf("明天零點：%v\n", tomorrowZero.Format("2006-01-02 15:04:05"))
    // 2. 獲取下月初零點（當(dāng)前時間+1個月，構(gòu)造當(dāng)月1號0點）
    nextMonth := now.AddDate(0, 1, 0)
    nextMonthZero := time.Date(
        nextMonth.Year(),
        nextMonth.Month(),
        1,          // 每月1號
        0, 0, 0, 0, // 時、分、秒、納秒歸零
        now.Location(), // 保持與當(dāng)前時間時區(qū)一致
    )
    fmt.Printf("下月初零點：%v\n", nextMonthZero.Format("2006-01-02 15:04:05"))
    // 擴(kuò)展：獲取本月最后一天23:59:59（下月初1號減1秒）
    thisMonthLastDay := nextMonthZero.Add(-1 * time.Second)
    fmt.Printf("本月最后一天（23:59:59）：%v\n", thisMonthLastDay.Format("2006-01-02 15:04:05"))
}