package main
import (
	"context"
	"fmt"
	"time"
)
// 超時(shí)控制示例
func main() {
	// 設(shè)置超時(shí)時(shí)間, 2秒后超時(shí)
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	// 延遲取消操作，防止內(nèi)存泄漏
	defer cancel()
	// 模擬一個(gè)耗時(shí)操作
	go func() {
		// 模擬耗時(shí)操作，此處僅為演示
		time.Sleep(3 * time.Second) //
		fmt.Println("任務(wù)完成")
	}()
	// 等待超時(shí)或任務(wù)完成
	select {
	// 超時(shí)或任務(wù)完成都會(huì)執(zhí)行到這里
	case <-ctx.Done():
		fmt.Println("超時(shí)了:", ctx.Err())
	}
}

package main
import (
	"context"
	"fmt"
	"net/http"
	"time"
)
func main() {
	// 模擬請(qǐng)求超時(shí)
	start := time.Now() // 記錄開始時(shí)間
	// 設(shè)置超時(shí)時(shí)間, 超時(shí)后會(huì)自動(dòng)取消請(qǐng)求
	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
	// 請(qǐng)求結(jié)束后取消超時(shí)設(shè)置
	defer cancel()
	// 發(fā)起請(qǐng)求
	req, _ := http.NewRequestWithContext(ctx, "GET", "https://httpbin.org/delay/2", nil)
	// 創(chuàng)建客戶端發(fā)起請(qǐng)求
	client := &http.Client{}
	// 發(fā)起請(qǐng)求, 超時(shí)后會(huì)自動(dòng)取消
	resp, err := client.Do(req)
	// 判斷請(qǐng)求是否超時(shí)
	if err != nil {
		fmt.Println("請(qǐng)求失敗:", err)
		fmt.Println("1", time.Since(start)) // 打印請(qǐng)求耗時(shí)
		return
	}
	// 關(guān)閉響應(yīng)體
	defer resp.Body.Close()
	fmt.Println("請(qǐng)求成功:", resp.Status)   // 打印響應(yīng)狀態(tài)碼
	fmt.Println("2", time.Since(start)) // 打印請(qǐng)求耗時(shí)
}

package main
import (
	"context"
	"fmt"
	"time"
)
// worker 模擬一個(gè)工作線程
func worker(ctx context.Context) {
	for {
		select { // 使用select監(jiān)聽ctx.Done()信號(hào)
		case <-ctx.Done(): // 監(jiān)聽到ctx.Done()信號(hào)，退出循環(huán)
			fmt.Println("worker 退出:", ctx.Err())
			return
		default: // 未監(jiān)聽到ctx.Done()信號(hào)，繼續(xù)工作
			fmt.Println("工作中...")
			time.Sleep(500 * time.Millisecond)
		}
	}
}
// main 模擬主線程
func main() {
	start := time.Now()                                                     // 記錄開始時(shí)間
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // 設(shè)置超時(shí)時(shí)間
	defer cancel()                                                          // 延遲取消，確保主線程退出時(shí)能夠釋放資源
	go worker(ctx)                                                          // 啟動(dòng)工作線程
	time.Sleep(3 * time.Second)                                             // 主線程等待3秒后退出
	fmt.Println("main 退出耗時(shí):", time.Since(start))                            // 打印耗時(shí)
}

package main
import (
	"context"
	"fmt"
	"time"
)
// service層調(diào)用dao層查詢數(shù)據(jù)，如果2秒內(nèi)沒有查詢到結(jié)果，則取消查詢
func service(ctx context.Context) {
	dao(ctx)
}
// dao層模擬查詢數(shù)據(jù)，如果3秒內(nèi)沒有查詢到結(jié)果，則返回完成
func dao(ctx context.Context) {
	select { // 等待查詢結(jié)果或超時(shí)
	case <-time.After(3 * time.Second):
		fmt.Println("查詢完成")
	case <-ctx.Done():
		fmt.Println("查詢被取消:", ctx.Err())
	}
}
func main() {
	// 設(shè)置超時(shí)時(shí)間，2秒后自動(dòng)取消查詢
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel() // 確保在main函數(shù)結(jié)束時(shí)取消上下文，避免資源泄露
	service(ctx) // 調(diào)用service層
}

ctx, _ := context.WithTimeout(context.Background(), 1*time.Second)
// 忘記 cancel

ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second) // 正確寫法
defer cancel() // 確保在函數(shù)結(jié)束時(shí)取消上下文，避免資源泄露

func worker(ctx context.Context) {
	// 完全沒用 ctx
	time.Sleep(10 * time.Second)
}

func worker(ctx context.Context) {
	select {
	case <-time.After(10 * time.Second):
	case <-ctx.Done():
		return
	}
}

for i := 0; i < 10000; i++ {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel() // 錯(cuò)誤！
}

for i := 0; i < 10000; i++ {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	// 使用 ctx
	cancel() // 及時(shí)釋放
}

ctx = context.WithValue(ctx, "userID", 123)

type keyType struct{}
ctx = context.WithValue(ctx, keyType{}, 123)

type Context interface {
	Deadline() (deadline time.Time, ok bool)
	Done() <-chan struct{}
	Err() error
	Value(key any) any
}

type cancelCtx struct {
	Context
	mu       sync.Mutex
	done     chan struct{}
	children map[canceler]struct{}
	err      error
}

parent
 ├── child1
 ├── child2
      └── grandchild

type timerCtx struct {
	cancelCtx
	timer *time.Timer
	deadline time.Time
}

select {
case <-time.After(1 * time.Second):
}

type MyContext struct {
	done chan struct{}
}
func NewContext() *MyContext {
	return &MyContext{
		done: make(chan struct{}),
	}
}
func (c *MyContext) Done() <-chan struct{} {
	return c.done
}
func (c *MyContext) Cancel() {
	close(c.done)
}

type MyContext struct {
	done     chan struct{}
	children []*MyContext
}