Go语言学习之context包的用法详解_Golang_

// 睡眠5s，模拟长时间操作 func FuncB() (interface{}, error) {  time.Sleep(5 * time.Second)  return struct{}{}, nil } func FuncA() (interface{}, error) {  var res interface{}  var err error  ch := make(chan interface{})   // 调用FuncB()，将结果保存至 channel 中  go func() {   res, err = FuncB()   ch <- res  }()   // 设置一个2s的定时器  timer := time.NewTimer(2 * time.Second)      // 监测是定时器先结束，还是 FuncB 先返回结果  select {          // 超时，返回默认值  case <-timer.C:   return "default", err          // FuncB 先返回结果，关闭定时器，返回 FuncB 的结果  case r := <-ch:   if !timer.Stop() {    <-timer.C   }   return r, err  } } func main() {  res, err := FuncA()  fmt.Println(res, err) } 

const LogKey = "LogKey" // 模拟一个日志打印，每次从 Context 中取出 LogKey 对应的 Value 作为LogID type Logger struct{} func (logger *Logger) info(ctx context.Context, msg string) {  logId, ok := ctx.Value(LogKey).(string)  if !ok {   logId = uuid.New().String()  }  fmt.Println(logId + " " + msg) } var logger Logger // 日志打印 并 调用 FuncB func FuncA(ctx context.Context) {  logger.info(ctx, "FuncA")  FuncB(ctx) } func FuncB(ctx context.Context) {  logger.info(ctx, "FuncB") } // 获取初始化的，带有 LogID 的 Context，一般在程序入口做 func getLogCtx(ctx context.Context) context.Context {  logId, ok := ctx.Value(LogKey).(string)  if ok {   return ctx  }  logId = uuid.NewString()  return context.WithValue(ctx, LogKey, logId) } func main() {  ctx = getLogCtx(context.Background())  FuncA(ctx) } 

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

 func Stream(ctx context.Context, out chan<- Value) error {   for {          // 处理数据    v, err := DoSomething(ctx)    if err != nil {     return err    }          // ctx.Done() 读取到数据，说明获取到了任务取消的信号    select {    case <-ctx.Done():     return ctx.Err()     // 否则将结果输出，继续计算    case out <- v:    }   }  } 

func main() {  ctx := context.Background()  c := context.WithValue(ctx, "key", "value")  v, ok := c.Value("key").(string)  fmt.Println(v, ok) } 

var (  background = new(emptyCtx)  todo       = new(emptyCtx) ) func Background() Context {  return background } func TODO() Context {  return todo } 

type emptyCtx int func (*emptyCtx) Deadline() (deadline time.Time, ok bool) {  return } func (*emptyCtx) Done() <-chan struct{} {  return nil } func (*emptyCtx) Err() error {  return nil } func (*emptyCtx) Value(key interface{}) interface{} {  return nil } func (e *emptyCtx) String() string {  switch e {  case background:   return "context.Background"  case todo:   return "context.TODO"  }  return "unknown empty Context" } 

func main() {  ctx := context.Background()  c := context.WithValue(ctx, "myKey", "myValue")  v1 := c.Value("myKey")  fmt.Println(v1.(string))  v2 := c.Value("hello")  fmt.Println(v2) //  nil } 

type valueCtx struct {  Context  key, val interface{} } 

func WithValue(parent Context, key, val interface{}) 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} } 

func (c *valueCtx) Value(key interface{}) interface{} {  if c.key == key {   return c.val  }  return c.Context.Value(key) } 

func doSomething(ctx context.Context) (interface{}, error) {  res := make(chan interface{})  go func() {   fmt.Println("do something")   time.Sleep(time.Second * 5)   res <- "done"  }()  select {  case <-ctx.Done():   return nil, ctx.Err()  case value := <-res:   return value, nil  } } func main() {  ctx, cancel := context.WithCancel(context.Background())  go func() {   time.Sleep(time.Second * 2)   cancel()  }()  res, err := doSomething(ctx)  fmt.Println(res, err) // nil , context canceled } 

type canceler interface {  cancel(removeFromParent bool, err error)  Done() <-chan struct{} } // closedchan is a reusable closed channel. var closedchan = make(chan struct{}) func init() {  close(closedchan) } var Canceled = errors.New("context canceled") 

type CancelFunc func() 

var cancelCtxKey int 

type cancelCtx struct {  Context  mu       sync.Mutex            // 保护如下字段，保证线程安全  
                
提示：
                    本文由神整理自网络，如有侵权请联系本站删除！
                    

                    本站声明： 

                    1、本站所有资源均来源于互联网，不保证100%完整、不提供任何技术支持； 

                    2、本站所发布的文章以及附件仅限用于学习和研究目的;不得将用于商业或者非法用途；否则由此产生的法律后果，本站概不负责！
                
                

                

                                            
上一篇：go语言算法题解二叉树的最小深度_Golang_
                                                                
下一篇：Go语言实现ssh&scp的方法详解_Golang_