golang中context的作用详解
当一个goroutine可以启动其他goroutine，而这些goroutine可以启动其他goroutine，依此类推，则第一个goroutine应该能够向所有其它goroutine发送取消信号。
上下文包的唯一目的是在goroutine之间执行取消信号，而不管它们如何生成。上下文的接口定义为：
type context interface {
deadline() (deadline time.time, ok bool)
done() <- chan struct{}
err() error
value(key interface{}) interface{}
}
- deadline：第一个值是截止日期，此时上下文将自动触发“取消”操作。第二个值是布尔值，true表示设置了截止日期，false表示未设置截止时间。如果没有设置截止日期，则必须手动调用cancel函数来取消上下文。
- done：返回一个只读通道（仅在取消后），键入struct {}，当该通道可读时，表示父上下文已经发起了取消请求，根据此信号，开发人员可以执行一些清除操作，退出goroutine
- err：返回取消上下文的原因
- value：返回绑定到上下文的值，它是一个键值对，因此您需要传递一个key来获取相应的值，此值是线程安全的
要创建上下文，必须指定父上下文。两个内置上下文（背景和待办事项）用作*父上下文：
var (
background = new(emptyctx)
todo = new(emptyctx)
)
func background() context {
return background
}
func todo() context {
return todo
}
背景，主要ü在主函数，初始化和测试代码的sed，是树结构中，根上下文，这是不能被取消的顶层语境。todo，当您不知道要使用什么上下文时，可以使用它。它们本质上都是emptyctx类型，都是不可取消的，没有固定的期限，也没有为context赋任何值：键入emptyctx int
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 withcancel（父上下文）（ctx上下文，取消cancelfunc）func withdeadline（父上下文，截止时间.time）（上下文，cancelfunc）func withtimeout（父上下文，超时时间。持续时间）（上下文，cancelfunc）func withvalue（父上下文，键，val接口{}）上下文
请注意，这些方法意味着可以一次继承上下文以实现其他功能，例如，使用withcancel函数传入根上下文，它会创建一个子上下文，该子上下文具有取消上下文的附加功能，然后使用此方法将context（context01）作为父上下文，并将其作为第一个参数传递给withdeadline函数，与子context（context01）相比，获得子context（context02），它具有一个附加功能，可在之后自动取消上下文最后期限。
withcancel
对于通道，尽管通道也可以通知许多嵌套的goroutine退出，但通道不是线程安全的，而上下文是线程安全的。
例如：
package main
import (
"runtime"
"fmt"
"time"
"context"
)
func monitor2(ch chan bool, index int) {
for {
select {
case v := <- ch:
fmt.printf("monitor2: %v, the received channel value is: %v, ending\n", index, v)
return
default:
fmt.printf("monitor2: %v in progress...\n", index)
time.sleep(2 * time.second)
}
}
}
func monitor1(ch chan bool, index int) {
for {
go monitor2(ch, index)
select {
case v := <- ch:
// this branch is only reached when the ch channel is closed, or when data is sent(either true or false)
fmt.printf("monitor1: %v, the received channel value is: %v, ending\n", index, v)
return
default:
fmt.printf("monitor1: %v in progress...\n", index)
time.sleep(2 * time.second)
}
}
}
func main() {
var stopsingal chan bool = make(chan bool, 0)
for i := 1; i <= 5; i = i + 1 {
go monitor1(stopsingal, i)
}
time.sleep(1 * time.second)
// close all gourtines
cancel()
// waiting 10 seconds, if the screen does not display <monitorx: xxxx in progress...>, all goroutines have been shut down
time.sleep(10 * time.second)
println(runtime.numgoroutine())
println("main program exit!!!!")
}
执行的结果是：
monitor1: 5 in progress...
monitor2: 5 in progress...
monitor1: 2 in progress...
monitor2: 2 in progress...
monitor2: 1 in progress...
monitor1: 1 in progress...
monitor1: 4 in progress...
monitor1: 3 in progress...
monitor2: 4 in progress...
monitor2: 3 in progress...
monitor1: 4, the received channel value is: false, ending
monitor1: 3, the received channel value is: false, ending
monitor2: 2, the received channel value is: false, ending
monitor2: 1, the received channel value is: false, ending
monitor1: 1, the received channel value is: false, ending
monitor2: 5, the received channel value is: false, ending
monitor2: 3, the received channel value is: false, ending
monitor2: 3, the received channel value is: false, ending
monitor2: 4, the received channel value is: false, ending
monitor2: 5, the received channel value is: false, ending
monitor2: 1, the received channel value is: false, ending
monitor1: 5, the received channel value is: false, ending
monitor1: 2, the received channel value is: false, ending
monitor2: 2, the received channel value is: false, ending
monitor2: 4, the received channel value is: false, ending
1
main program exit!!!!
这里使用一个通道向所有goroutine发送结束通知，但是这里的情况相对简单，如果在一个复杂的项目中，假设多个goroutine有某种错误并重复执行，则可以重复关闭或关闭该通道通道，然后向其写入值，从而触发运行时恐慌。这就是为什么我们使用上下文来避免这些问题的原因，以withcancel为例：
package main
import (
"runtime"
"fmt"
"time"
"context"
)
func monitor2(ctx context.context, number int) {
for {
select {
case v := <- ctx.done():
fmt.printf("monitor: %v, the received channel value is: %v, ending\n", number,v)
return
default:
fmt.printf("monitor: %v in progress...\n", number)
time.sleep(2 * time.second)
}
}
}
func monitor1(ctx context.context, number int) {
for {
go monitor2(ctx, number)
select {
case v := <- ctx.done():
// this branch is only reached when the ch channel is closed, or when data is sent(either true or false)
fmt.printf("monitor: %v, the received channel value is: %v, ending\n", number, v)
return
default:
fmt.printf("monitor: %v in progress...\n", number)
time.sleep(2 * time.second)
}
}
}
func main() {
var ctx context.context = nil
var cancel context.cancelfunc = nil
ctx, cancel = context.withcancel(context.background())
for i := 1; i <= 5; i = i + 1 {
go monitor1(ctx, i)
}
time.sleep(1 * time.second)
// close all gourtines
cancel()
// waiting 10 seconds, if the screen does not display <monitor: xxxx in progress>, all goroutines have been shut down
time.sleep(10 * time.second)
println(runtime.numgoroutine())
println("main program exit!!!!")
}
withtimeout和withdeadline
withtimeout和withdeadline在用法和功能上基本相同，它们都表示上下文将在一定时间后自动取消，唯一的区别可以从函数的定义中看出，传递给withdeadline的第二个参数是类型time.duration类型，它是一个相对时间，表示取消超时后的时间。例：
package main
import (
"runtime"
"fmt"
"time"
"context"
)
func monitor2(ctx context.context, index int) {
for {
select {
case v := <- ctx.done():
fmt.printf("monitor2: %v, the received channel value is: %v, ending\n", index, v)
return
default:
fmt.printf("monitor2: %v in progress...\n", index)
time.sleep(2 * time.second)
}
}
}
func monitor1(ctx context.context, index int) {
for {
go monitor2(ctx, index)
select {
case v := <- ctx.done():
// this branch is only reached when the ch channel is closed, or when data is sent(either true or false)
fmt.printf("monitor1: %v, the received channel value is: %v, ending\n", index, v)
return
default:
fmt.printf("monitor1: %v in progress...\n", index)
time.sleep(2 * time.second)
}
}
}
func main() {
var ctx01 context.context = nil
var ctx02 context.context = nil
var cancel context.cancelfunc = nil
ctx01, cancel = context.withcancel(context.background())
ctx02, cancel = context.withdeadline(ctx01, time.now().add(1 * time.second)) // if it's withtimeout, just change this line to "ctx02, cancel = context.withtimeout(ctx01, 1 * time.second)"
defer cancel()
for i := 1; i <= 5; i = i + 1 {
go monitor1(ctx02, i)
}
time.sleep(5 * time.second)
if ctx02.err() != nil {
fmt.println("the cause of cancel is: ", ctx02.err())
}
println(runtime.numgoroutine())
println("main program exit!!!!")
}
withvalue
一些必需的元数据也可以通过上下文传递，该上下文将附加到上下文中以供使用。元数据作为键值传递，但请注意，键必须具有可比性，并且值必须是线程安全的。
package main
import (
"runtime"
"fmt"
"time"
"context"
)
func monitor(ctx context.context, index int) {
for {
select {
case <- ctx.done():
// this branch is only reached when the ch channel is closed, or when data is sent(either true or false)
fmt.printf("monitor %v, end of monitoring. \n", index)
return
default:
var value interface{} = ctx.value("nets")
fmt.printf("monitor %v, is monitoring %v\n", index, value)
time.sleep(2 * time.second)
}
}
}
func main() {
var ctx01 context.context = nil
var ctx02 context.context = nil
var cancel context.cancelfunc = nil
ctx01, cancel = context.withcancel(context.background())
ctx02, cancel = context.withtimeout(ctx01, 1 * time.second)
var ctx03 context.context = context.withvalue(ctx02, "nets", "champion") // key: "nets", value: "champion"
defer cancel()
for i := 1; i <= 5; i = i + 1 {
go monitor(ctx03, i)
}
time.sleep(5 * time.second)
if ctx02.err() != nil {
fmt.println("the cause of cancel is: ", ctx02.err())
}
println(runtime.numgoroutine())
println("main program exit!!!!")
}
关于上下文，还有一些注意事项：不要将context存储在结构类型中，而是将context明确传递给需要它的每个函数，并且context应该是第一个参数。
即使函数允许，也不要传递nil context，或者如果您不确定要使用哪个context，请传递context。不要将可能作为函数参数传递给上下文值的变量传递。
到此这篇关于golang中context的作用的文章就介绍到这了,更多相关golang中context的作用内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！