扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > GO >go语言context包功能及操作使用详解
  • 548

0
分享到

go语言context包功能及操作使用详解

2024-04-02 19:04:59 548人浏览 安东尼
摘要

目录Context包到底是干嘛用的？context原理什么时候应该使用 Context？如何创建 Context？主协程通知有子协程，子协程又有多个子协程context核心接口emp

Context包到底是干嘛用的？

我们会在用到很多东西的时候都看到context的影子，比如gin框架，比如grpc，这东西到底是做啥的？
大家都在用，没几个知道这是干嘛的，知其然而不知其所以然

原理说白了就是：

  • 当前协程取消了，可以通知所有由它创建的子协程退出
  • 当前协程取消了，不会影响到创建它的父级协程的状态
  • 扩展了额外的功能：超时取消、定时取消、可以和子协程共享数据

context原理

这就是context包的核心原理，链式传递context，基于context构造新的context

什么时候应该使用 Context？

  • 每一个 rpc 调用都应该有超时退出的能力，这是比较合理的 api 设计
  • 不仅仅 是超时，你还需要有能力去结束那些不再需要操作的行为
  • context.Context 是 Go 标准的解决方案
  • 任何函数可能被阻塞，或者需要很长时间来完成的，都应该有个 context.Context

如何创建 Context？

在 RPC 开始的时候，使用 context.Background()

有些人把在 main() 里记录一个 context.Background()，然后把这个放到服务器的某个变量里，然后请求来了后从这个变量里继承 context。这么做是不对的。直接每个请求，源自自己的 context.Background() 即可。

如果你没有 context，却需要调用一个 context 的函数的话，用 context.TODO()

如果某步操作需要自己的超时设置的话，给它一个独立的 sub-context（如前面的例子）

主协程通知有子协程，子协程又有多个子协程

package main
import (
    "context"
    "fmt"
    "time"
)
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    //缓冲通道预先放置10个消息
    messages := make(chan int, 10)
    defer close(messages)
    for i := 0; i < 10; i++ {
        messages <- i
    }
    //启动3个子协程消费messages消息
    for i := 1; i <= 3; i++ {
        go child(i, ctx, messages)
    }
    time.Sleep(3 * time.Second) //等待子协程接收一半的消息
    cancel() //结束前通知子协程
    time.Sleep(2 * time.Second) //等待所有的子协程输出
    fmt.Println("主协程结束")
}
//从messages通道获取信息，当收到结束信号的时候不再接收
func child(i int, ctx context.Context, messages <-chan int) {
    //基于父级的context建立context
    newCtx, _ := context.WithCancel(ctx)
    go childJob(i, "a", newCtx)
    go childJob(i, "b", newCtx)
Consume:
    for {
        time.Sleep(1 * time.Second)
        select {
        case <-ctx.Done():
            fmt.Printf("[%d]被主协程通知结束...\n", i)
            break Consume
        default:
            fmt.Printf("[%d]接收消息: %d\n", i, <-messages)
        }
    }
}
//任务
func childJob(parent int, name string, ctx context.Context) {
    for {
        time.Sleep(1 * time.Second)
        select {
        case <-ctx.Done():
            fmt.Printf("[%d-%v]被结束...\n", parent, name)
            return
        default:
            fmt.Printf("[%d-%v]执行\n", parent, name)
        }
    }
}

运行结果如下

可以看到，改成context包还是顺利的通过子协程退出了
主要修改了几个地方，再ctx向下传递

基于上层context再构建当前层级的context

监听context的退出信号，

这就是context包的核心原理，链式传递context，基于context构造新的context

context核心接口

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

 Deadline返回绑定当前context的任务被取消的截止时间；如果没有设定期限，将返回ok == false。

Done 当绑定当前context的任务被取消时，将返回一个关闭的channel；如果当前context不会被取消，将返回nil。

Err 如果Done返回的channel没有关闭，将返回nil;如果Done返回的channel已经关闭，将返回非空的值表示任务结束的原因。如果是context被取消，Err将返回Canceled；如果是context超时，Err将返回DeadlineExceeded。

Value 返回context存储的键值对中当前key对应的值，如果没有对应的key,则返回nil。

emptyCtx结构体

实现了context接口，emptyCtx没有超时时间，不能取消，也不能存储额外信息，所以emptyCtx用来做根节点，一般用Background和TODO来初始化emptyCtx

Backgroud

通常用于主函数，初始化以及测试，作为顶层的context

context.Background()

TODO

不确定使用什么用context的时候才会使用

valueCtx结构体

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

valueCtx利用Context的变量来表示父节点context，所以当前context继承了父context的所有信息
valueCtx还可以存储键值。

WithValue向context添加值

可以向context添加键值

func WithValue(parent Context, key, val interface{}) Context {
    if key == nil {
        panic("nil key")
    }
    if !reflect.TypeOf(key).Comparable() {
        panic("key is not comparable")
    }
    return &amp;valueCtx{parent, key, val}
}

添加键值会返回创建一个新的valueCtx子节点

Value向context取值

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

可以用来获取当前context和所有的父节点存储的key

如果当前的context不存在需要的key，会沿着context链向上寻找key对应的值，直到根节点

示例

package main
import (
	"context"
	"fmt"
	"time"
)
func main() {
	ctx := context.WithValue(context.Background(), "name1", "root1")

	//第一层
	go func(parent context.Context) {
		ctx = context.WithValue(parent, "name2", "root2")
		//第二层
		go func(parent context.Context) {
			ctx = context.WithValue(parent, "name3", "root3")
			//第三层
			go func(parent context.Context) {
				//可以获取所有的父类的值
				fmt.Println(ctx.Value("name1"))
				fmt.Println(ctx.Value("name2"))
				fmt.Println(ctx.Value("name3"))
				//不存在
				fmt.Println(ctx.Value("name4"))
			}(ctx)
		}(ctx)
	}(ctx)
	time.Sleep(1 * time.Second)
	fmt.Println("end")
}

运行结果

可以看到，子context是可以获取所有父级设置过的key

WithCancel可取消的context

用来创建一个可取消的context，返回一个context和一个CancelFunc，调用CancelFunc可以触发cancel操作。

package main
import (
	"context"
	"fmt"
	"time"
)
func main() {
	ctx, cancel := context.WithCancel(context.Background())
	//第一层
	go func(parent context.Context) {
		ctx, _ := context.WithCancel(parent)
		//第二层
		go func(parent context.Context) {
			ctx, _ := context.WithCancel(parent)
			//第三层
			go func(parent context.Context) {
				waitCancel(ctx, 3)
			}(ctx)
			waitCancel(ctx, 2)
		}(ctx)
		waitCancel(ctx, 1)
	}(ctx)
	// 主线程给的结束时间
	time.Sleep(2 * time.Second)
	cancel() // 调用取消context
	time.Sleep(1 * time.Second)
}
func waitCancel(ctx context.Context, i int) {
	for {
		time.Sleep(time.Second)
		select {
		case <-ctx.Done():
			fmt.Printf("%d end\n", i)
			return
		default:
			fmt.Printf("%d do\n", i)
		}
	}
}

结果：

cancelCtx结构体

type cancelCtx struct {
    Context
    mu sync.Mutex
    done chan struct{}
    children map[canceler]struct{}
    err error
}
type canceler interface {
    cancel(removeFromParent bool, err error)
    Done() &lt;-chan struct{}
}

WithDeadline-超时取消context

返回一个基于parent的可取消的context，并且过期时间deadline不晚于所设置时间d

WithTimeout-超时取消context

创建一个定时取消context，和WithDeadline差不多，WithTimeout是相对时间

timerCtx结构体

timerCtx是基于cancelCtx的context精英，是一种可以定时取消的context，过期时间的deadline不晚于所设置的时间d

示例：

package main
import (
	"context"
	"fmt"
	"time"
)
func main() {
	// 设置超时时间
	ctx, _ := context.WithTimeout(context.Background(), 2*time.Second)
	//第一层
	go func(parent context.Context) {
		ctx, _ := context.WithCancel(parent)
		//第二层
		go func(parent context.Context) {
			ctx, _ := context.WithCancel(parent)
			//第三层
			go func(parent context.Context) {
				waitCancel(ctx, 3)
			}(ctx)
			waitCancel(ctx, 2)
		}(ctx)
		waitCancel(ctx, 1)
	}(ctx)

	<-ctx.Done()
	// 给时间调用end
	time.Sleep(time.Second)
}
func waitCancel(ctx context.Context, i int) {
	for {
		time.Sleep(time.Second)
		select {
		case <-ctx.Done():
			fmt.Printf("%d end\n", i)
			return
		default:
			fmt.Printf("%d do\n", i)
		}
	}
}

运行结果：

1 do
3 do
2 do
1 end
3 end
2 end

可以看到，虽然我们没有调用cancel方法，5秒后自动调用了，所有的子goroutine都已经收到停止信号

总结核心原理

  • Done方法返回一个channel
  • 外部通过调用<-channel监听cancel方法
  • cancel方法会调用close(channel)
    当调用close方法的时候，所有的channel再次从通道获取内容，会返回零值和false
res,ok := &lt;-done:
  • 过期自动取消，使用了time.AfterFunc方法，到时调用cancel方法
  c.timer = time.AfterFunc(dur, func() {
   c.cancel(true, DeadlineExceeded)
  })

以上就是go语言context包功能及操作使用详解的详细内容，更多关于go语言context包的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

--结束END--

本文标题: go语言context包功能及操作使用详解

本文链接: https://lsjlt.com/news/146068.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • go语言context包功能及操作使用详解
    目录Context包到底是干嘛用的？context原理什么时候应该使用 Context？如何创建 Context？主协程通知有子协程，子协程又有多个子协程context核心接口emp...
    99+
    2024-04-02
  • go语言context包功能及操作使用的方法
    本篇内容介绍了“go语言context包功能及操作使用的方法”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！Context包到底是干嘛用的？我...
    99+
    2023-06-30
  • Go语言学习之context包的用法详解
    目录前言需求一需求二Context 接口emptyCtxvalueCtx类型定义WithValuecancelCtx类型定义cancelCtxWithCanceltimerCtx类型...
    99+
    2024-04-02
  • Go语言基础学习之Context的使用详解
    目录前言基本用法Context控制goroutine的生命周期使用 WithValue() 传递数据使用 WithCancel() 取消操作使用 WithDeadline() 设置截...
    99+
    2023-05-19
    Go语言Context使用 Go语言Context用法 Go Context
  • Go语言中的IO操作及Flag包的用法
    一、格式化输入和输出 1.从终端获取用户的输入 fmt.Scanf 空格作为分隔符，占位符和格式化输出的一致 fmt.Scan 从终端获取用户的输入，存储在Scanln中的参数里，空...
    99+
    2024-04-02
  • go语言定时器Timer及Ticker的功能使用示例详解
    目录定时器1-"*/5 * * * * *"设置说明定时器2-Timer-TickerTimer-只执行一次Ticker-循环执行Timer延时功能停止和重置定时...
    99+
    2024-04-02
  • GO语言包管理工具go mod以及包详解
    目录1.GO中包的定义与介绍2. 包管理工具 go mod2.1 自定义包 (可以包含多个go文件)2.1.1 建立项目并go mod init初始化2.1.2 自定义一个包(文件夹...
    99+
    2024-04-02
  • Go语言os包用法详解
    目录os 包中的常用函数os/exec 执行外部命令os/user 获取当前用户信息os/signal 信号处理Go语言的 os 包中提供了操作系统函数的接口，是一个比较重要的包。顾...
    99+
    2023-05-14
    Go语言os包 Go os包使用
  • Go语言中的I/O操作详解
    Go语言是一种由Google开发的开源编程语言，其设计注重简洁、高效和并发性能。在Go语言中，I/O操作是非常常见且重要的一部分，本文将详细介绍Go语言中的I/O操作，包括文件读写、网...
    99+
    2024-04-02
  • 详解Go语言中的Slice链式操作
    目录示例原理实现示例 首先模拟一个业务场景，有订单、产品、自定义订单三个结构体，订单中包含多个产品： type Order struct { Id string Pr...
    99+
    2023-05-15
    Go Slice链式操作 Go Slice操作 Go Slice
  • 详解Go语言中的数据库操作
    目录原生SQL方式ORM方式数据库是应用开发中必须要掌握的技巧，通常在数据库开发过程中，会有两种不同的方式： 直接使用SQL语句，这种方式下，直接编写SQL，简单直观，但是可维护性较...
    99+
    2023-02-07
    Go语言数据库操作 Go语言数据库 Go 数据库
  • Go语言并发之原子操作详解
    目录修改赋值与读取比较并交换小结代码中的加锁操作因为涉及内核态的上下文切换会比较耗时、代价比较高。针对基本数据类型我们还可以使用原子操作来保证并发安全，因为原子操作是Go语言提供的方...
    99+
    2022-12-29
    Go语言 并发 原子操作 Go语言 原子操作 Go语言 并发
  • 详解Go语言中使用for循环进行翻转操作
    标题：Go语言中使用for循环进行翻转操作的详细解析 在Go语言中，使用for循环进行数组、切片等数据结构的翻转操作是一种常见的需求。通过for循环，可以遍历数组或切片中的元素，并实现...
    99+
    2024-04-02
  • 详解Go语言中rand(随机数)包的使用
    目录包"math/rand"随机数种子随机函数rand.Int()rand.Intn(n)实例其他随机函数按类型随机类指定随机范围类伪随机排列的切片生成标准正态分...
    99+
    2024-04-02
  • Go语言文件读写操作案例详解
    目录基本介绍文件基本操作读操作写操作写操作案例查看文件或目录是否存在拷贝文件基本介绍 文件,对我们并不陌生,文件是数据源(保存数据的地方)的 一种 输入流和输出流 文件在程序中是以流...
    99+
    2024-04-02
  • 详解Go语言变量作用域
    目录局部变量全局变量形式参数初始化局部和全局变量作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。 Go 语言中变量可以在三个地方声明： 函数内定...
    99+
    2022-06-07
    详解go语言 GO go语言 作用域 变量
  • win8.1语言包安装怎么操作？win8/8.1语言包安装教程详解
    win8.1语言包怎么安装下文小编将介绍win8/8.1语言包安装教程，我们该如何为Windows8.1系统安装自己需要的语言包呢感兴趣的朋友们通过下文的教程来了解吧。 win8.1语言包安装教程： 1、在系统下同时按住...
    99+
    2023-06-07
    win8.1 语言包安装 语言包 教程 win8
  • C语言操作符#与##使用方法详解
    目录一、# 运算符二、## 运算符三、小结一、# 运算符 # 运算符用于在预处理期将宏参数转换为字符串# 的转换作用是在预处理期完成的，因此只在宏定义中有效编译器不知道 # 的转换作...
    99+
    2024-04-02
  • Rxjava功能操作符的使用方法详解
    Rxjava功能个人感觉很好用，里面的一些操作符很方便，Rxjava有：被观察者，观察者，订阅者，被观察者通过订阅者订阅观察者，从而实现观察者监听被观察者返回的数据下面把Rxjava常用的模型代码列出来，还有一些操作符的运用：依赖：comp...
    99+
    2023-05-30
    rxjava 操作符 作
  • Go语言中sync.Cond使用详解
    目录sync.Cond 可以用来干什么？ 与 Sync.Mutex 的区别 sync.Cond 使用场景 sync.Cond sync.Cond 有哪些方法 NewCond 创建实例...
    99+
    2024-04-02
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作