3W 解析 Golang Context：用法、源码

package main
import (    "fmt"    "time")
// 全局变量，用于存储上下文信息var (    deadline time.Time    requestID string)
func main() {    // 设置上下文信息    deadline = time.Now().Add(5 * time.Second)    requestID = "123456"    // 启动一个goroutine来处理任务    go func() {        for {            select {            case <-time.After(1 * time.Second):                // 模拟一些耗时的操作                fmt.Println("goroutine 1: doing some work")            default:                // 检查上下文信息，如果已经超时或被取消了，就退出循环                if time.Now().After(deadline) {                    fmt.Println("goroutine 1: context canceled")                    return                }            }        }    }()
    // 启动另一个 goroutine 来处理任务    go func() {        for {            select {            case <-time.After(1 * time.Second):                // 模拟一些耗时的操作                fmt.Println("goroutine 2: doing some work")            default:                // 检查上下文信息，如果已经超时或被取消了，就退出循环                if time.Now().After(deadline) {                    fmt.Println("goroutine 2: context canceled")                    return                }            }        }    }()
    // 等待一段时间，然后取消上下文信息    time.Sleep(3 * time.Second)    fmt.Println("main: context canceled")    deadline = time.Now()    time.Sleep(1 * time.Second)}

package main
import (    "context"    "fmt"    "time")
func main() {    // 创建一个带有截止时间的 context    ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))    defer cancel()    // 启动一个 goroutine 来处理任务    go func(ctx context.Context) {        for {            select {            case <-ctx.Done():                // 如果 context 被取消了，就退出循环                fmt.Println("goroutine 1: context canceled")                return            default:                // 模拟一些耗时的操作，普通情况可能是rpc调用                time.Sleep(1 * time.Second)                fmt.Println("goroutine 1: doing some work")            }        }    }(ctx)    // 启动另一个 goroutine 来处理任务    go func(ctx context.Context) {        for {            select {            case <-ctx.Done():                // 如果 context 被取消了，就退出循环                fmt.Println("goroutine 2: context canceled")                return            default:                // 模拟一些耗时的操作                time.Sleep(1 * time.Second)                fmt.Println("goroutine 2: doing some work")            }        }    }(ctx)    // 等待一段时间，然后取消 context    time.Sleep(3 * time.Second)    cancel()    fmt.Println("main: context canceled")    time.Sleep(1 * time.Second)}

// Conetext 包介绍 ：通常context携带截止时间，**和取消信号**，以及其他跨越API边界的值，Context的方法可以被多个协程同时调用。package context
type Context interface {  // 返回截止的日期，如果无截止日期，ok返回false  Deadline() (deadline time.Time, ok bool)  // 返回一个channel，当工作已完成或者上下文被取消时关闭。如果是一个不会被取消的上下文，Done会返回nil  // WithCancel方法，会在被调用cancel时，关闭Done  // WithDeadline方法，会在过截止时间时，关闭Done  // WithTimeout方法，会在超时结束时，关闭Done  Done() <-chan struct{}  // Done没有被关闭时，会返回nil  // 如果Done关闭了，将会返回关闭的原因(取消、超时)  Err() error  // 返回与当前上下文关联的键值或nil。如果没有值与键关联，使用相同键连续调用 Value 会返回相同的结果  Value(key interface{}) interface{}}

func (c *cancelCtx) Done() <-chan struct{} {  // 原子变量加载看是否存通道信息  d := c.done.Load()  if d != nil {    return d.(chan struct{})  }  c.mu.Lock()  defer c.mu.Unlock()  d = c.done.Load()  if d == nil {    d = make(chan struct{})    c.done.Store(d)  }  return d.(chan struct{})}

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {  if parent == nil {    panic("cannot create context from nil parent")  }  if cur, ok := parent.Deadline(); ok && cur.Before(d) {    // The current deadline is already sooner than the new one.    return WithCancel(parent)  }  c := &timerCtx{    cancelCtx: newCancelCtx(parent),    deadline:  d,  }  propagateCancel(parent, c)  dur := time.Until(d)  if dur <= 0 {    c.cancel(true, DeadlineExceeded, nil) // deadline has already passed    return c, func() { c.cancel(false, Canceled, nil) }  }  c.mu.Lock()  defer c.mu.Unlock()  if c.err == nil {    c.timer = time.AfterFunc(dur, func() {      c.cancel(true, DeadlineExceeded, nil)    })  }  return c, func() { c.cancel(true, Canceled, nil) }}

func (c *timerCtx) cancel(removeFromParent bool, err, cause error) {  c.cancelCtx.cancel(false, err, cause)  if removeFromParent {    // Remove this timerCtx from its parent cancelCtx's children.    removeChild(c.cancelCtx.Context, c)  }  c.mu.Lock()  if c.timer != nil {    c.timer.Stop()    c.timer = nil  }  c.mu.Unlock()}

func WithValue(parent Context, key, val any) Context {  if parent == nil {    panic("cannot create context from nil parent")  }  if key == nil {    panic("nil key")  }  if !reflectlite.TypeOf(key).Comparable() {    panic("key is not comparable")  }  return &valueCtx{parent, key, val}}

package main
import (  "context"  "fmt")
func main() {  // 初始化一个context  ctx := context.Background()  // 设置系统配置信息到 context 中  config := Config{LogLevel: "info", Timeout: 200}  ctx = context.WithValue(ctx, "config", config)  // 测试获取配置信息  c := getConfig(ctx)  fmt.Println("LogLevel:", c.LogLevel)  fmt.Println("Timeout:", c.Timeout)}
type Config struct {  LogLevel string  Timeout  int}
// 模拟获取系统配置信息的函数func getConfig(ctx context.Context) Config {  // 从 ctx 中获取配置信息  config, ok := ctx.Value("config").(Config)  if !ok {    return Config{LogLevel: "debug", Timeout: 100}  }  return config}

func (c *valueCtx) Value(key any) any {  if c.key == key {    return c.val  }  return value(c.Context, key)}
func value(c Context, key any) any {  for {    switch ctx := c.(type) {    case *valueCtx:      if key == ctx.key {        return ctx.val      }      c = ctx.Context    case *cancelCtx:      if key == &cancelCtxKey {        return c      }      c = ctx.Context    case *timerCtx:      if key == &cancelCtxKey {        return ctx.cancelCtx      }      c = ctx.Context    case *emptyCtx:      return nil    default:      return c.Value(key)    }  }}

  ctx = context.WithValue(ctx, "config", config)  ctx = context.WithValue(ctx, "test", "1")  ctx = context.WithValue(ctx, "test2", "3")  // 测试获取配置信息  c := getConfig(ctx)