Go 超时控制：context 与 timeout从实战到原理解析

package main
import (
	"context"
	"fmt"
	"time"
)
// 超时控制示例
func main() {
	// 设置超时时间, 2秒后超时
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	// 延迟取消操作，防止内存泄漏
	defer cancel()
	// 模拟一个耗时操作
	go func() {
		// 模拟耗时操作，此处仅为演示
		time.Sleep(3 * time.Second) //
		fmt.Println("任务完成")
	}()
	// 等待超时或任务完成
	select {
	// 超时或任务完成都会执行到这里
	case <-ctx.Done():
		fmt.Println("超时了:", ctx.Err())
	}
}

package main
import (
	"context"
	"fmt"
	"net/http"
	"time"
)
func main() {
	// 模拟请求超时
	start := time.Now() // 记录开始时间
	// 设置超时时间, 超时后会自动取消请求
	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
	// 请求结束后取消超时设置
	defer cancel()
	// 发起请求
	req, _ := http.NewRequestWithContext(ctx, "GET", "https://httpbin.org/delay/2", nil)
	// 创建客户端发起请求
	client := &http.Client{}
	// 发起请求, 超时后会自动取消
	resp, err := client.Do(req)
	// 判断请求是否超时
	if err != nil {
		fmt.Println("请求失败:", err)
		fmt.Println("1", time.Since(start)) // 打印请求耗时
		return
	}
	// 关闭响应体
	defer resp.Body.Close()
	fmt.Println("请求成功:", resp.Status)   // 打印响应状态码
	fmt.Println("2", time.Since(start)) // 打印请求耗时
}

package main
import (
	"context"
	"fmt"
	"time"
)
// worker 模拟一个工作线程
func worker(ctx context.Context) {
	for {
		select { // 使用select监听ctx.Done()信号
		case <-ctx.Done(): // 监听到ctx.Done()信号，退出循环
			fmt.Println("worker 退出:", ctx.Err())
			return
		default: // 未监听到ctx.Done()信号，继续工作
			fmt.Println("工作中...")
			time.Sleep(500 * time.Millisecond)
		}
	}
}
// main 模拟主线程
func main() {
	start := time.Now()                                                     // 记录开始时间
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) // 设置超时时间
	defer cancel()                                                          // 延迟取消，确保主线程退出时能够释放资源
	go worker(ctx)                                                          // 启动工作线程
	time.Sleep(3 * time.Second)                                             // 主线程等待3秒后退出
	fmt.Println("main 退出耗时:", time.Since(start))                            // 打印耗时
}

package main
import (
	"context"
	"fmt"
	"time"
)
// service层调用dao层查询数据，如果2秒内没有查询到结果，则取消查询
func service(ctx context.Context) {
	dao(ctx)
}
// dao层模拟查询数据，如果3秒内没有查询到结果，则返回完成
func dao(ctx context.Context) {
	select { // 等待查询结果或超时
	case <-time.After(3 * time.Second):
		fmt.Println("查询完成")
	case <-ctx.Done():
		fmt.Println("查询被取消:", ctx.Err())
	}
}
func main() {
	// 设置超时时间，2秒后自动取消查询
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel() // 确保在main函数结束时取消上下文，避免资源泄露
	service(ctx) // 调用service层
}

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

ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second) // 正确写法
defer cancel() // 确保在函数结束时取消上下文，避免资源泄露

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() // 错误！
}

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

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
}