首先要和大家说声抱歉哈，由于工作上、生活上的某些琐事，以至于造成本节的断更。不过请不要悲伤。因为我在这期间也是做过详细的复习的。我相信一定会让你有更加深入的理解，同时也欢迎你向我提出不足。我们共同进步。话不多说，我相信你已经迫不及待了。还在等什么？let‘s GO
在本文中，我首先会介绍context是什么，它有什么作用，以及如何使用，其中还会参杂一点个人的理解，以及部分源码的了解。What are you waiting for?
来自官方文档
Context包定义了上下文类型，该类型在API边界之间以及进程之间传递截止日期，取消信号和其他请求范围的值
对服务器的传入请求应创建一个Context，而对服务器的传出调用应接受一个Context。
它们之间的函数调用链必须传播Context，可以选择将其替换为使用WithCancel，WithDeadline，WithTimeout或WithValue创建的派生Context。取消上下文后，从该上下文派生的所有上下文也会被取消。
WithCancel，WithDeadline和WithTimeout函数采用Context（父级）并返回派生的Context（子级）和CancelFunc。调用CancelFunc会取消该子代及其子代，删除父代对该子代的引用，并停止所有关联的计时器。未能调用CancelFunc会使子代及其子代泄漏，直到父代被取消或计时器触发。审核工具检查所有控制流路径上是否都使用了CancelFuncs。
使用上下文的程序应遵循以下规则，以使各个包之间的接口保持一致，并使静态分析工具可以检查上下文传播：
不要将上下文存储在结构类型中；而是将上下文明确传递给需要它的每个函数。 Context应该是第一个参数，通常命名为ctx：
func DoSomething(ctx context.Context, arg Arg) error {
// ... use ctx ...
}
即使函数允许，也不要传递nil Context。如果不确定使用哪个上下文，请传递context.TODO
仅将上下文值用于传递过程和API的请求范围数据，而不用于将可选参数传递给函数。
可以将相同的上下文传递给在不同goroutine中运行的函数。上下文可以安全地被多个goroutine同时使用
巴拉巴拉，说了一大堆，反正我一句没懂，当然我知道context是干嘛的，（尬～，不小心暴露了，学渣的本质），说说我的理解以及使用建议
对服务器的传入请求应创建一个Context，而对服务器的传出响应也应接受一个Context。
函数调用链必须传播Context，也可以选择将其替换为使用WithCancel，WithDeadline，WithTimeout或WithValue创建的派生Context(也就是子类context)。取消上下文后，从该上下文派生的所有上下文也会被取消
Context 不要放在结构体中，要以参数的方式传递。
Context 作为函数的参数时，要放在第一位，也就是第一个参数。
要使用 context.Background 函数生成根节点的 Context，也就是最顶层的 Context。
Context 传值要传递必须的值，而且要尽可能地少，不要什么都传。
Context 多协程安全，可以在多个协程中放心使用。
Context 是Go 1.7 标准库引入 的标准库，中文译作“上下文”，准确说它是 goroutine 的上下文，包含 goroutine 的运行状态、环境、现场等信息。
使用context，我们可以轻松优雅的做到取消goroutine，超时时间,运行截止时间，k-v存储等。它是并发安全的
随着 context 包的引入，标准库中很多接口因此加上了 context 参数，例如 database/sql 包。context 几乎成为了并发控制和超时控制的标准做法。
context.Context 类型的值可以协调多个 groutine 中的代码执行“取消”操作，并且可以存储键值对。最重要的是它是并发安全的。
与它协作的 API 都可以由外部控制执行“取消”操作，例如：取消一个 HTTP 请求的执行。
止于这些么？当然 不止,还有更多的骚操作，接下来让我们一起拿下它吧。
为什么需要使用context，理由一
一个协程启动后，大部分情况需要等待里面的代码执行完毕，然后协程会自行退出。但需要让协程提前退出怎么办呢？
下面我们以一个小的示例，来逐渐了解context的妙用之一吧
package main
import (
"fmt"
"sync"
"time"
)
func monitor(name string) {
//开启for select循环，j进行后台监控
for {
select {
default:
fmt.Printf("Time: %v 监控者:%s, 正在监控...n", time.Now().Unix(), name)
}
// sleep 1 second
time.Sleep(time.Second * 5)
fmt.Printf("%s 监控完成，一切正常，请指示 over...n", name)
}
}
func main() {
var wg sync.WaitGroup
// Define waiting group
wg.Add(1)
go func() {
// Execution complete
defer wg.Done()
monitor("天眼")
}()
//Exit after waiting
wg.Wait()
}
我们在这里实现了一个基本的groutine执行的case
我们定义了等待组
wait group,防止协程提前退出。关于wait group可参考上一篇文章，golang并发控制的心应手。
他会周期性的运行，不断打印监控信息，例如
那么我们完成上述的那个需求提前退出,那么该怎么办呢？其中一个方法就是定义一个全局的sign，其他地方可以通过修改这个sign发出停止监控的指令。然后在协程中先检查这个变量，如果发现被通知关闭就停止监控，退出当前协程。从而实现可控制提前退出。示例代码如下
package main
import (
"fmt"
"sync"
"time"
)
func monitor1(signCh chan bool, MonitoringPeriod time.Duration, name string, ) {
//开启for select循环，一直后台监控
for {
select {
case <-signCh:
fmt.Println(name, "停止指令已收到，停止...")
return
default:
fmt.Printf("Time: %v [监控者]:%s, 正在监控...n", time.Now().Unix(), name)
}
time.Sleep(MonitoringPeriod * time.Second)
}
}
func main() {
var wg sync.WaitGroup
signCh := make(chan bool) //sign 用来停止监控
const MonitoringTime, MonitoringPeriod = 20, 2
wg.Add(1)
go func() {
defer wg.Done()
monitor1(signCh, MonitoringPeriod, "天眼")
}()
time.Sleep(MonitoringTime * time.Second) //实施监控时间
signCh <- true //发停止指令
wg.Wait()
}
这样我们就实现了，可控制话的groutine退出，但如果在新增几个定期的任务功能，那该如何是好？
管他的，我们先把这个弄懂了先。老夫先干为敬。首先我们先看程序运行图，如下
这个示例是使用 select+channel 的方式改造，实现了通过 channel 发送指令让监控狗停止，进而达到协程退出的目的。
首先我们定义了sync.WaitGroup，防止gorontine提前退出。signCh，他是一个bool值类型channel，用于发送sign后续的退出。
MonitoringTime，MonitoringPeriod，监控时间与监控周期。second。
然后创建goroutine执行select+channel。
为 函数增加 signCh 参数，用于接收停止指令；
在 main 函数中，声明用于停止的 signCh，传递给 monitor1 函数，然后通过 signCh<-true 发送停止指令让协程退出。
通过 select+channel 让协程退出的方式比较优雅，以下几个问题也随之凸显
但如果我们希望做到同时取消很多个协程呢？
如果是定时取消协程又该怎么办？
这时候 select+channel 的局限性就凸现出来了，即使定义了多个 channel 解决问题，当然这个方式是可行的，但代码逻辑也会非常复杂、难以维护。
要解决这种复杂的协程问题，必须有一种可以跟踪协程的方案，只有跟踪到每个协程，才能更好地控制它们，这种方案就是 Go 语言标准库为我们提供的 Context，接下来我们体验一下它的强大之处吧。
package main
import (
"context"
"fmt"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
const MonitoringTime, MonitoringPeriod = 20, 2
wg.Add(1)
// 定义一个等待的 `context`
ctx, stop := context.WithCancel(context.Background())
go func() {
defer wg.Done()
monitor2(ctx, MonitoringPeriod, "天眼")
}()
time.Sleep(MonitoringTime * time.Second) //先监控5秒
stop() //发停止指令
wg.Wait()
}
func monitor2(ctx context.Context, MonitoringPeriod time.Duration, name string, ) {
//开启for select循环，一直后台监控
for {
select {
case <-ctx.Done():
fmt.Println(name, "停止指令已收到，停止...")
return
default:
fmt.Printf("Time: %v [监控者]:%s, 正在监控...n", time.Now().Unix(), name)
}
time.Sleep(MonitoringPeriod * time.Second)
}
}
是不是很优雅呢？确实如此，那么为什么也可以达到上面使用channel，的效果呢。那么我们去看一下它的具体实现部分呢，
WithCancel以下是WithCancel：具体实现部分代码
WithCancel:返回具有新的“完成”通道的父级副本。当调用返回的cancel函数或关闭父上下文的Done通道时（以先发生的为准），将关闭返回的上下文的Done通道。取消此上下文将释放与其关联的资源，因此在此上下文中运行的操作完成后，代码应立即调用cancel。
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) }
}
除了WithCancel，之外还有WithDeadline,WithTimeout,WithValue,首先我们来继续看看WithDeadline具体实现，以及使用技巧吧
WithTimeoutfunc 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))
}
取消此上下文将释放与之关联的资源，因此在此上下文中运行的操作完成后，代码应立即调用cancel：
来看一下具体如何使用吧，示例如下
package main
import (
"context"
"fmt"
"time"
)
func main() {
// 创建一个子节点的context,3秒后自动超时
const MonitoringTime, MOnitoringPeriod= 20, 2
ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
go func() {
monitor4(ctx, MonitoringPeriod, "天眼")
fmt.Println("退出时间",time.Now().Unix())
}()
time.Sleep(MonitoringTime * time.Second)
cancel()
}
func monitor4(ctx context.Context, MonitoringPeriod time.Duration, name string, ) {
//开启for select循环，一直后台监控
for {
select {
case <-ctx.Done():
fmt.Println(name, "停止指令已收到，停止...")
return
default:
fmt.Printf("Time: %v [监控者]:%s, 正在监控...n", time.Now().Unix(), name)
time.Sleep(MonitoringPeriod * time.Second)
}
}
}
以上会有两种情况发生退出，
一、程序main退出，全局退出
二、我们定义的timeout退出
他们的基本性质与使用我们就简单的过了一遍，下面让我们来个小结。
WithCancel(parent Context)：生成一个可取消的 Context。
WithDeadline(parent Context, d time.Time)：生成一个可定时取消的 Context，参数 d 为定时取消的具体时间。
WithTimeout(parent Context, timeout time.Duration)：生成一个可超时取消的 Context，参数 timeout 用于设置多久后取消
WithValue(parent Context, key, val interface{})：生成一个可携带 key-value 键值对的 Context。
是不是发现，其实也没有那么难呢？当然，它本来就很简单，接下来我们来点更刺激的，同时取消多goroutine，啥也不说了，上～
package main
import (
"context"
"fmt"
"strconv"
"sync"
"time"
)
var wg sync.WaitGroup
func main() {
const MonitoringTime, MOnitoringPeriod= 20, 2
wg.Add(1)
ctx, stop := context.WithCancel(context.Background())
for i := 0; i <3; i++ {
go monitor6(ctx, MonitoringPeriod, strconv.Itoa(i))
}
time.Sleep(MonitoringTime * time.Second) //先监控5秒
stop() //发停止指令
wg.Wait()
}
func monitor6(ctx context.Context, MonitoringPeriod time.Duration, name string, ) {
defer wg.Done()
//开启for select循环，一直后台监控
for {
select {
case <-ctx.Done():
fmt.Println(name, "停止指令已收到，停止...")
return
default:
fmt.Printf("Time: %v [监控者]:天眼%s, 正在监控...n", time.Now().Unix(), name)
}
time.Sleep(MonitoringPeriod * time.Second)
}
}
Time: 1612948086 [监控者]:天眼0, 正在监控…
Time: 1612948086 [监控者]:天眼1, 正在监控…
Time: 1612948086 [监控者]:天眼2, 正在监控…
… …
Time: 1612948104 [监控者]:天眼2, 正在监控…
Time: 1612948104 [监控者]:天眼0, 正在监控…
Time: 1612948104 [监控者]:天眼1, 正在监控…
2 停止指令已收到，停止…
1 停止指令已收到，停止…
0 停止指令已收到，停止…
你以为这样就完了么，这只是一个小的case，它还可以管理子节点。其管理与树形结构十分的相似。
除此之外还可以传递值，接下来让我们来看看吧
package main
import (
"context"
"fmt"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
ctx, stop := context.WithCancel(context.Background())
ctxVal := context.WithValue(ctx, "user", "payne")
wg.Add(1)
go func() {
defer wg.Done()
getValue(ctxVal)
}()
time.Sleep(3)
stop()
wg.Wait()
}
func getValue(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("exit")
return
default:
user := ctx.Value("user")
fmt.Println("【获取用户】", "用户为：", user)
time.Sleep(1 * time.Second)
}
}
}
输出如下
【获取用户】 用户为： payne
exit…
总结：
Context为我们主要定义四种方法WithDeadline,WithTimeout,WithValue,WithCancel,从而达到控制goroutine的目的，但却不仅限于我们以上介绍的那样(只介绍了一层，其实可以是多层。形成多对多的关系)，它更深层次的使用你可以想象成多叉树的情况。
context，这一篇就暂且完成啦，期待下一篇。并发模式
并发模式，故名思义。他与设计模式一样，即使用goroutine并发的一些总结。
我将与你探讨
Goroutine WorkPool:让我们随影所欲的控制创建gototine的数量，且复用。期待～
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有