context源码学习

最新推荐文章于 2022-11-04 09:10:34 发布
最新推荐文章于 2022-11-04 09:10:34 发布
阅读量787 收藏
点赞数
分类专栏： GO 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leekerian/article/details/126810483
版权 
type Context interface {
	// Deadline 如果context 被设置了超时，Deadline 将会返回超时时限
	Deadline() (deadline time.Time, ok bool)
	// Done 返回一个只读的channel, 这个channel只能读取，没有地方写入，一旦将这个channel close，可以根据读取出来的nil做通信处理
	Done() <-chan struct{}
	// Err 返回context结束时的error信息
	Err() error
	// Value 类似于map，根据key返回对应的value值
	Value(key any) any
}

注意**<-chan struct{}**这是golang中的一个语法糖，表示这个channel只读，不能写入。
Context本质上是一个interface，他提供了四个接口,具体的注释很长，可以看源码的英文注释。
其中Value，为了防止 Key 冲突，最好将 Key 的类型定义为非导出类型，然后为其定义访问器。看一个通过 Context 共享用户信息的例子：

package user

import "context"

// User 是要存于 Context 中的 Value 类型.
type User struct {...}

// key 定义为了非导出类型，以避免和其他 package 中的 key 冲突
type key int

// userKey 是 Context 中用来关联 user.User 的 key，是非导出变量
// 客户端需要用 user.NewContext 和 user.FromContext 构建包含
// user 的 Context 和从 Context 中提取相应 user 
var userKey key

// NewContext 返回一个带有用户值 u 的 Context.
func NewContext(ctx context.Context, u *User) context.Context {
  return context.WithValue(ctx, userKey, u)
}

// FromContext 从 Context 中提取 user，如果有的话.
func FromContext(ctx context.Context) (*User, bool) {
  u, ok := ctx.Value(userKey).(*User)
  return u, ok
}

emptyCtx

空的context

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 any) any {
	return nil
}

func (e *emptyCtx) String() string {
	switch e {
	case background:
		return "context.Background"
	case todo:
		return "context.TODO"
	}
	return "unknown empty Context"
}

var (
	background = new(emptyCtx)
	todo       = new(emptyCtx)
)

func Background() Context {
	return background
}

func TODO() Context {
	return todo
}

emptyCtx一般作为context的根节点，我们可以看到empty只是实现了context的四个函数，但是没有做相应的逻辑处理，返回nil值。我们可以通过Background跟TODO构建相应的context。当我们不知道context用来干什么的时候可以用TODO，预留一下context。

valueCtx

// A valueCtx carries a key-value pair. It implements Value for that key and
// delegates all other calls to the embedded Context.
type valueCtx struct {
	Context
	key, val any
}

valueCtx用来存储相应的key跟value。我们可以用WithValue函数来创建相应的value context。

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")
	}
	// 再包一层key跟value值
	return &valueCtx{parent, key, val}
}

我们可以看到WithValue其实就是将传进来的context再包一层key跟value，返回。

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)
		}
	}
}

我们可以通过调用Value函数获取key对应的value值。整个过程调用的是value函数，这个函数的过程我们可以理解为剥洋葱，一层一层获取父级context。其中的cancelCtxKey比较特别，是用来查找从当前的context出发最近的祖先cancel context节点。后面的cancelCtx会用到。

cancelCtx

首先看下cancelCtx的结构体

type cancelCtx struct {
	// 父级context
	Context
	// mutex锁
	mu       sync.Mutex            // protects following fields
	// 采用atomic.Value来存储close channel
	done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
	// 儿子节点
	children map[canceler]struct{} // set to nil by the first cancel call
	// 错误信息
	err      error                 // set to non-nil by the first cancel call
}

type canceler interface {
	// cancel函数，将所有的child接口cancel
	cancel(removeFromParent bool, err error)
	Done() <-chan struct{}
}

同样的也提供了WithCancel函数用来获得一个cancelCtx

func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	// 先做参数校验
	if parent == nil {
		panic("cannot create context from nil parent")
	}
	// new一个cancelCtx，主要就是绑定父级context
	c := newCancelCtx(parent)
	// propagateCancel比较关键， propagateCancel可以理解为挂载，将child节点挂在离child节点最近的祖先cancelCtx节点
	propagateCancel(parent, &c)
	// 返回cancelCtx 以及 相应的cancel函数，如果调用cancel函数会将所有的child context cancel掉，注意cancel传递的第一个参数是true，表示要将该节点从父亲节点中摘除
	return &c, func() { c.cancel(true, Canceled) }
}

func newCancelCtx(parent Context) cancelCtx {
	return cancelCtx{Context: parent}
}

接下来重点看下propagateCancel

// propagateCancel主要是将child挂载在离child节点最近的祖先cancelCtx节点
func propagateCancel(parent Context, child canceler) {
	// 首先做参数校验
	done := parent.Done()
	if done == nil {
		return // parent is never canceled
	}
	// 判断父亲节点是否已经被cancel，如果被cancel就要将child也关闭，因为既然父亲节点已经cancel，那么在父亲节点下的所有子节点都要cancel
	select {
	case <-done:
		// parent is already canceled
		child.cancel(false, parent.Err())
		return
	default:
	}
	//找到第一个离parent最近的祖先cancelCtx节点
	if p, ok := parentCancelCtx(parent); ok {
		p.mu.Lock()
		if p.err != nil {
			// parent has already been canceled
			child.cancel(false, p.err)
		} else {
			if p.children == nil {
				p.children = make(map[canceler]struct{})
			}
			// 找到了就将child节点挂载在p节点下
			p.children[child] = struct{}{}
		}
		p.mu.Unlock()
	} else {
		// 提供对第三方context支持，如果是第三方的context就开goroutine做监听
		atomic.AddInt32(&goroutines, +1)
		go func() {
			select {
			case <-parent.Done():
				child.cancel(false, parent.Err())
			case <-child.Done():
			}
		}()
	}
}

func parentCancelCtx(parent Context) (*cancelCtx, bool) {
	done := parent.Done()
	if done == closedchan || done == nil {
		return nil, false
	}
	p, ok := parent.Value(&cancelCtxKey).(*cancelCtx)
	if !ok {
		return nil, false
	}
	pdone, _ := p.done.Load().(chan struct{})
	if pdone != done {
		return nil, false
	}
	return p, true
}

func (c *cancelCtx) Value(key any) any {
	if key == &cancelCtxKey {
		return c
	}
	return value(c.Context, key)
}

接下来看下另一个关键的函数cancel


var Canceled = errors.New("context canceled")
var DeadlineExceeded error = deadlineExceededError{}

// 第一参数表示是否将当前的节点从父亲节点中摘除，第二参数返回因为什么而cancel，只能是Canceled or DeadlineExceeded
func (c *cancelCtx) cancel(removeFromParent bool, err error) {
	if err == nil {
		panic("context: internal error: missing cancel error")
	}
	c.mu.Lock()
	// 如果err非nil说明已经被其他goroutine cancel了
	if c.err != nil {
		c.mu.Unlock()
		return // already canceled
	}
	c.err = err
	// 原子加载channel
	d, _ := c.done.Load().(chan struct{})
	if d == nil {
		// 如果为nil那么就原子存储一下一个关闭的channel
		c.done.Store(closedchan)
	} else {
		// 关闭channel
		close(d)
	}
	// 递归便利所有挂载的child节点，将当前节点下的所有子节点全部cancel
	for child := range c.children {
		// NOTE: acquiring the child's lock while holding parent's lock.
		child.cancel(false, err)
	}
	// 置空child节点
	c.children = nil
	c.mu.Unlock()
	
	// 将节点从父亲节点中摘除
	if removeFromParent {
		removeChild(c.Context, c)
	}
}

func removeChild(parent Context, child canceler) {
	// 找到第一个离parent节点最近的祖先cancelCtx节点
	p, ok := parentCancelCtx(parent)
	if !ok {
		return
	}
	p.mu.Lock()
	if p.children != nil {
		// 从祖先节点的map中将child删除
		delete(p.children, child)
	}
	p.mu.Unlock()
}

cancelCtx的主要操作就是创建一个cancelCtx的时候会用(剥洋葱)找到第一个离当前的cancelCtx最近的祖先cancelCtx，并将当前新建的cancelCtx挂载当祖先节点中。cancel的时候就是递归遍历自己的map，将自己所有子孙cancelCtx的channel都close掉，再将自己从父亲节点中摘除。摘除之后就交给GC做回收了。

timerCtx

type timerCtx struct {
	cancelCtx
	timer *time.Timer // Under cancelCtx.mu.

	deadline time.Time
}

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) // deadline has already passed
		return c, func() { c.cancel(false, Canceled) }
	}
	c.mu.Lock()
	defer c.mu.Unlock()
	if c.err == nil {
		c.timer = time.AfterFunc(dur, func() {
			c.cancel(true, DeadlineExceeded)
		})
	}
	return c, func() { c.cancel(true, Canceled) }
}

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) {
	return WithDeadline(parent, time.Now().Add(timeout))
}

timerCtx只是在cancelCtx的基础上再加了一个计时器，时间到了的时候就调用cancel函数。

推荐阅读

https://www.qtmuniao.com/2020/07/12/go-context/
https://www.cnblogs.com/qcrao-2018/p/11007503.html

kelianlee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android context源码详解及深入分析
08-31
通过深入学习和分析Context的源码，可以更深刻地了解Android系统的运行机制，提升开发能力。 总结来说，Android Context是应用程序组件与系统交互的桥梁，它封装了与Android系统服务的通信，提供了资源加载、组件...
Context：源码解读
qq_36059306的博客
06-30 237
Context 针对场景 传递上下文 控制子goroutine的执行 超时控制的方法调用 可以取消的方法调用 基本用法 type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{} } Deadline：返回Context被取消的截止日期，如果没有截止日期那么ok返回false Do
context包使用及原码分析
weixin_43807568的博客
11-29 315
context包使用及原码分析 文章目录context包使用及原码分析前言一、context使用场景1.值传递2.取消机制3.timeout机制4.deadline机制二、context源码分析1.抽象接口2.根context3.值传递（valueCtx）总结 前言 context 包在 Go 1.7 中引入，它为我们提供了一种在应用程序中处理 context 的方法。 一、context使用场景 1.值传递 代码如下（示例）： package main import ( "context" "f
React Context源码是怎么实现的呢
weixin_59558923的博客
11-04 234
Context 提供了一个无需为每层组件手动添加 props，就能在组件树间进行数据传递的方法。一个顶层数据，想要传递到某些深层组件，通过props逐层传递将会非常繁琐，使用 Context 可避免显式地通过组件树逐层传递props。
EVP_DecryptFinal_ex:bad decrypt
dtryl的专栏
06-07 6159
启动wss服务,发现报错: _tls_common.js:156 c.context.setKey(key, passphrase); ^ Error: error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt 经过研究
context 源码解析
星星点灯的博客
12-09 335
package context import ( "errors" "internal/reflectlite" "sync" "sync/atomic" "time" ) //每个context 都要实现的接口 type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{.
tomcat源码学习之环境搭建
12-04
在深入探讨Tomcat源码学习之前，我们首先要理解Tomcat是什么。Tomcat是一款开源的、免费的Web服务器和Servlet容器，由Apache软件基金会维护。它实现了Java Servlet和JavaServer Pages（JSP）规范，是Java EE应用...
Spring-context4.1.0的源码
09-20
Spring-context4.1.0的源码，我们在学习Spring源码时，可以在ide中添加源码方便追溯运行过程
tomcat9 源码学习
01-21
源码学习对于理解Tomcat的工作原理、优化性能以及自定义功能至关重要。以下是一些在学习Tomcat9源码时会涉及的关键知识点： 1. **架构概述**：Tomcat由多个组件构成，如Catalina（核心Servlet容器）、 Coyote...
tomcat源码学习
08-03
【标题】"Tomcat源码学习"涉及到的是对Apache Tomcat服务器内部运行机制的深入理解。Tomcat是一款广泛使用的开源Java Servlet容器，它实现了Java EE的Web应用规范，特别是Servlet和JSP。源码学习是提升技术水平、...
Android Context完全解析，你所不知道的Context的各种细节
热门推荐
郭霖的专栏
11-09 17万+
Context相信所有的Android开发人员基本上每天都在接触，因为它太常见了。但是这并不代表Context没有什么东西好讲的，实际上Context有太多小的细节并不被大家所关注，那么今天我们就来学习一下那些你所不知道的细节。我们知道，Android应用都是使用Java语言来编写的，那么大家可以思考一下，一个Android程序和一个Java程序，他们最大的区别在哪里？划分界限又是什么呢？其实简单点分析，Android程序不像Java程序一样，随便创建一个类，写个main()方法就能跑了，而是要有一个完整的
Android Context 源码的理解
programming_path的博客
11-03 975
Context 是什么 类的剖析 Context ContextImpl ContextWrapper ContextThemeWrapper Context 创建的时机 Application 的创建 Activity 的启动 Service Context 的数量 不同 Context 的分析 Application 中的 Context Activity 中的Context Serv
Android应用Context详解及源码解析
工匠若水
05-27 2万+
【工匠若水 http://blog.csdn.net/yanbober 转载烦请注明出处，尊重分享成果】1 背景今天突然想起之前在上家公司（做TV与BOX盒子）时有好几个人问过我关于Android的Context到底是啥的问题，所以就马上要诞生这篇文章。我们平时在开发App应用程序时一直都在使用Context（别说你没用过，访问当前应用的资源、启动一个activity等都用到了Context），但
Context源码分析
weixin_30322405的博客
06-13 102
Context源码分析 我们做安卓开发，时时都在和Context打交道，那么Context到底是什么？有什么作用？如何与Application，Activity，Service等实例发生联系的？等等 Context是什么？ Context的字面意思是“上下文”，那么...
Go语言之 Context 实战与源码分析
dz45693的专栏
11-27 2589
本文主要简单介绍了Go语言(golang)中的context包。给出了context 的基本用法和使用建议，并从源码层面对其底层结构和具体实现原理进行分析。 1. 概述 以下分析基于 Go 1.17.1 1.1 什么是 Context 上下文 context.Context在Go 语言中用来设置截止日期、同步信号，传递请求相关值的结构体。上下文与 Goroutine 有比较密切的关系，是 Go 语言中独特的设计，在其他编程语言中我们很少见到类似的概念。 主要用于超时控制和多Goroutine间
Android中Context源码分析（一）
Flying snow
08-24 1759
Context源码解析
Context源码，再度重相逢
qq_42766267的博客
11-02 172
各位读者朋友们大家好，我是随波逐流的薯条。深秋了，前几天气温骤降，北京的人和狗都不愿意出门，趴在窝里冻的打寒颤。我的书房里没装空调，暖气要十一月中旬才来，每次想学习都得下很大的决心，所以这篇文章发出来时比预期又晚了几天~ 最近我的心也是冰冰的，我目前做在线数据开发，如果大家干过这活肯定知道，数据开发最重要的是数据口径，开发前一定得对清楚... 本人作为在这上面踩了很多坑的人这几天接需求时又掉进去了，一个需求在已经上线的情况下，不同来源的数据做diff总是对不上，一查就是口径不对，来来回回改了根据口径改了一
Spark源码分析-1.集群架构介绍和SparkContext源码分析
Bloddy的博客
02-09 361
Spark源码分析-1.集群架构介绍和SparkContext源码分析 在分析Spark源码之前，有必要把Spark的集群架构和SparkContext复习下，有助于后面对源码的理解。 Spark集群架构 本文的集群架构是建立在Standalone模式的，Yarn和Mesos类似 Spark架构： 名词解释： Client：客户端进程，负责提交作业到Master。Client进...
从源码角度看各种context
qq_33595823的博客
08-08 255
该博客仅因手机阅读不方便而创建，感兴趣同学可以微信搜索小专栏平台，订阅从源码角度看Android，支持作者原创 简介： 做应用开发的对Context的熟悉度应该是仅次于Activity和Service的。Context,英文名上下文场景，代表着对当前运行场景下的各种信息的一种封装。例如，需要调用四大组件进行工作都要调用到Context，同时，通过Context也可以获取到Resource, D...
flutter源码学习
最新发布
06-07
学习Flutter源码可以更深入地理解Flutter框架的实现原理，提高开发能力和解决问题的能力。以下是一些学习Flutter源码的建议： 1. 学习Flutter源码前，需要熟悉Dart语言，了解面向对象编程、泛型、异步编程等基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值