大佬教程收集整理的这篇文章主要介绍了Context包源码解析（附面经），大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。
Context就相当于一个树状结构
最后请回答一下这个问题：context包中的方法是线程安全吗？
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
type valueCtx struct {
Context
key, val interface{}
}
type cancelCtx struct {
Context
mu sync.Mutex // protects following fields
done 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 timerCtx struct {
cancelCtx
timer *time.Timer // Under cancelCtx.mu.
deadline time.Time
}
package context
...
var (
BACkground = new(emptyCtX)
todo = new(emptyCtX)
)
分别通过以下两个方法返回
其中BACkground()方法是返回初始化时自动实例化的BACkground对象，TODO方法跟BACkground()相同
func BACkground() Context {
return BACkground
}
TODO方法跟BACkground()相同
func TODO() Context {
return todo
}
emptyCtx是一个自定义的类型，底层类型为int，实现了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 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"
}
创建具有dealline的Context WithDeadline(parent Context, d time.TimE) (Context, CancelFunC)
创建具有取消方法的Context WithCancel(parent Context) (ctx Context, cancel CancelFunC)
创建具有超时的Context WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunC)
创建具有可保存键值的Context WithValue(parent Context, key, val interface{}) Context
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}
}
//重写了Context接口中的 Value(key interface{})方法
func (c *valueCtX) Value(key interface{}) interface{} {
//先从自己节点中的键对值去寻找
if c.key == key {
return c.val
}
//找不到就往上递归，依次寻找绑定的父节点的value
return c.Context.Value(key)
}
写一个小demo验证一下
func main() {
ctx := context.WithValue(context.BACkground(), "xiaofu", "test")
ctx1 := context.WithValue(ctx, "xiaofu1", "test1")
fmt.Println(ctx1.Value("xiaofu1"))
fmt.Println(ctx1.Value("xiaofu"))
}
//输出
test1
test
<nil>
//说明是会往上递归，直到找到BACkground的根节点
查看以下代码，都会发现每次新建Context，都会绑定父节点的Context
type cancelCtx struct {
Context //父节点
mu sync.Mutex // 锁
done chan struct{} // chAnnel，用于关闭
children map[canceler]struct{} // 用于储存子节点中的cancelCtx
err error // set to non-nil by the first cancel call
}
//重写了Value方法，当key为cancelCtxKey时，返回当前的cancelCtx，否则不断向上递归寻找cancelCtx
func (c *cancelCtX) Value(key interface{}) interface{} {
if key == &cancelCtxKey {
return c
}
return c.Context.Value(key)
}
//重写了Done方法
func (c *cancelCtX) Done() <-chan struct{} {
//上锁
c.mu.Lock()
//初始化done的chAnnel,根节点的Done()方法返回的是nil
if c.done == nil {
c.done = make(chan struct{})
}
d := c.done
//解锁
c.mu.Unlock()
return d
}
func (c *cancelCtX) Err() error {
c.mu.Lock()
err := c.err
c.mu.Unlock()
return err
}
var closedchan = make(chan struct{})
//用于控制取消操作的接口,其中因为cancelCtx实现了cancel方法和Done()方法，所以默认实现该接口
type canceler interface {
cancel(removeFromParent bool, err error)
Done() <-chan struct{}
}
func WithCancel(parent Context) (ctx Context, cancel CancelFunC) {
if parent == nil { //检查父节点
panic("cAnnot create context from nil parent")
}
c := newCancelCtx(parent)
propagateCancel(parent, &C)
return &c, func() { c.cancel(true, Canceled) }
}
//创建cancelCtx结构体，并绑定父节点
func newCancelCtx(parent Context) cancelCtx {
return cancelCtx{Context: parent}
}
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)
}
//把当前的父节点用一个中间对象cancelCtx做转换，同时绑定到timeCtx中
//约等于 temp := cancelCtx{Context: parent}
// c := &timerCtx{
// cancelCtx: temp,
// deadline: d,
// }
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) }
}
//相当于在当前时间dealline的基础上，往后延迟一段时间，所以可以调用WithDeadline方法
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunC) {
return WithDeadline(parent, time.Now().Add(timeout))
}
因为每次执行WithXXX方法，都会新建一个context对象，并且把父对象进行绑定。
见demo
func main() {
ctx := context.WithValue(context.BACkground(), "xiaofu", "test")
go func() {
_ = context.WithValue(ctx, "xiaofu", "test1")
}()
go func() {
_ = context.WithValue(ctx, "xiaofu", "test2")
}()
fmt.Println(ctx.Value("xiaofu"))
fmt.Println(ctx.Value("xiaofu"))
time.Sleep(3 * time.Second)
}
//输出
//test
//test
以上是大佬教程为你收集整理的Context包源码解析（附面经）全部内容，希望文章能够帮你解决Context包源码解析（附面经）所遇到的程序开发问题。
如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。