Go 语言从入门到实战
蔡超
Mobvista 技术副总裁兼首席架构师,前亚马逊(中国)首席软件架构师
48919 人已学习
新⼈⾸单¥59
课程目录
已完结/共 55 讲
第一章:Go语言简介 (4讲)
第二章:基本程序结构 (4讲)
第三章:常用集合 (3讲)
第四章:字符串 (1讲)
时长 16:47
第五章:函数 (2讲)
第六章:面向对象编程 (4讲)
第七章:编写好的错误处理 (2讲)
第八章:包和依赖管理 (2讲)
第九章:并发编程 (7讲)
第十章:典型并发任务 (5讲)
第十一章:测试 (3讲)
时长 11:48
时长 07:12
时长 06:15
第十二章:反射和Unsafe (3讲)
时长 08:18
时长 08:03
第十三章:常见架构模式的实现 (2讲)
第十四章:常见任务 (4讲)
时长 04:27
时长 05:14
第十五章:性能调优 (4讲)
第十六章:高可用性服务设计 (5讲)
Go 语言从入门到实战
登录|注册
留言
12
收藏
沉浸
阅读
分享
手机端
回顶部
当前播放: 29 | Context与任务取消
00:00 / 00:00
高清
  • 高清
1.0x
  • 2.0x
  • 1.5x
  • 1.25x
  • 1.0x
  • 0.75x
  • 0.5x
网页全屏
全屏
00:00
付费课程,可试看
01 | Go语言课程介绍
02 | 内容综述
03 | Go语言简介:历史背景、发展现状及语言特性
04 | 编写第一个Go程序
05 | 变量、常量以及与其他语言的差异
06 | 数据类型
07 | 运算符
08 | 条件和循环
09 | 数组和切片
10 | Map声明、元素访问及遍历
11 | Map与工厂模式,在Go语言中实现Set
12 | 字符串
13 | Go语言的函数
14 | 可变参数和defer
15 | 行为的定义和实现
16 | Go语言的相关接口
17 | 扩展与复用
18 | 不一样的接口类型,一样的多态
19 | 编写好的错误处理
20 | panic和recover
21 | 构建可复用的模块(包)
22 | 依赖管理
23 | 协程机制
24 | 共享内存并发机制
25 | CSP并发机制
26 | 多路选择和超时
27 | channel的关闭和广播
28 | 任务的取消
29 | Context与任务取消
30 | 只运行一次
31 | 仅需任意任务完成
32 | 所有任务完成
33 | 对象池
34 | sync.pool对象缓存
35 | 单元测试
36 | Benchmark
37 | BDD
38 | 反射编程
39 | 万能程序
40 | 不安全编程
41 | 实现pipe-filter framework
42 | 实现micro-kernel framework
43 | 内置JSON解析
44 | easyjson
45 | HTTP服务
46 | 构建RESTful服务
47 | 性能分析工具
48 | 性能调优示例
49 | 别让性能被锁住
50 | GC友好的代码
51 | 高效字符串连接
52 | 面向错误的设计
53 | 面向恢复的设计
54 | Chaos Engineering
55 | 结课测试&结束语
登录 后留言

全部留言(12)

  • 最新
  • 精选
Geek_338030
没讲context是干嘛的,直接就讲用来取消关联任务,感觉云里雾里的。

作者回复: context就是用于管理相关任务的上下文,包含了共享值的传递,超时,取消通知 type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{} } Deadline会返回一个超时时间,Goroutine获得了超时时间后,例如可以对某些io操作设定超时时间。 Done方法返回一个信道(channel),当Context被撤销或过期时,该信道是关闭的,即它是一个表示Context是否已关闭的信号。 当Done信道关闭后,Err方法表明Context被撤的原因。 Value可以让Goroutine共享一些数据,当然获得数据是协程安全的。但使用这些数据的时候要注意同步,比如返回了一个map,而这个map的读写则要加

2019-09-09
24
南宫云遥子
`cancel()`这里为啥不用向cancel传入ctx,像这样`cancel(ctx)`,我知道`ctx, cancel := context.WithCancel(context.Background())`这里返回的就是不用传参,不明白为啥不用传参,请老师解答一下,谢谢! ``` func TestCancelRelative(t *testing.T){ // use context.WithCancel() to create cancel context signal, use context.Background() to get context ctx, cancel := context.WithCancel(context.Background()) for i := 0; i < 10; i++ { // use context.Context definded a context go func(i int, ctx context.Context){ for { // cancel single task //if isCancel(cancelChan){ // cancel relative task if isCancelRelative(ctx){ break } time.Sleep(1 * time.Second) } fmt.Println(i, "done!") }(i, ctx) } cancel() // cancel(ctx) //raise error: too many arguments in call to cancel, have (context.Context), want() time.Sleep(1 * time.Second) } ```

作者回复: 这个cancel就是由相关的context生成的。参考下面的实例代码: package cancel_with_ctx import ( "fmt" "testing" ) func WithContext(ctx int) (Cancel func()) { return func() { fmt.Println("The value of ctx is ", ctx) } } func TestWithContext(t *testing.T) { cancel := WithContext(10) cancel() //output: The value of ctx is 10 }

2019-04-28
3
3
Geek_fa647d
老师,go有类似java中spring clound这种微服务框架吗?

作者回复: 推荐你一个,简单的 https://github.com/easierway/service_decorators/blob/master/README.md

2019-03-24
2
悠悠
老师您好,请问一下,ctx 是创建出来的子context ,调用也是子context的cancel函数,感觉并没有体现出,取消父context 之后,子context被取消的效果啊。 然后我尝试使用子context 创建孙context ,并没与打印出孙context的canceled. ctx := context.Background() // ctx2 是子context ,cancel 是取消函数 ctx2, cancel := context.WithCancel(ctx) for i := 0; i < 5; i++ { go func(i int, ctx3 context.Context) { for { if isCancel(ctx3) { break } time.Sleep(time.Millisecond * 10) } fmt.Println(i, "canceled") }(i, ctx2) // 传递子context } // 然后再通过子context创建孙context ctx4, _ := context.WithCancel(ctx2) go func(ctx4 context.Context) { for { if isCancel(ctx4) { break } fmt.Println(" ctx4 canceled") } }(ctx4) cancel() time.Sleep(time.Second * 1)

作者回复: 你的“fmt.Println(" ctx4 canceled")” 位置不对 package hh import ( "context" "fmt" "testing" "time" ) func isCancel(ctx context.Context) bool { select { case <-ctx.Done(): return true default: return false } } func TestContextCancelling(t *testing.T) { ctx := context.Background() // ctx2 是子context ,cancel 是取消函数 ctx2, cancel := context.WithCancel(ctx) for i := 0; i < 5; i++ { go func(i int, ctx3 context.Context) { for { if isCancel(ctx3) { break } time.Sleep(time.Millisecond * 10) } fmt.Println(i, "canceled") }(i, ctx2) // 传递子context } // 然后再通过子context创建孙context ctx4, _ := context.WithCancel(ctx2) go func(ctx4 context.Context) { fmt.Println("ctx4 started") for { if isCancel(ctx4) { break } //time.Sleep(time.Millisecond * 10) } fmt.Println(" ctx4 canceled") }(ctx4) cancel() time.Sleep(time.Second * 10) }

2023-12-21
Geek_马官人
上一讲是channel取消,这讲是context取消,都是取消任务,什么情况要用什么方式都没说,各种优缺点也没说,都是讲一点最基础的概念,然后一点最基础的代码,都不明白为什么要敲这种代码,听的很难受,每个东西都完全串不起来,讲的很差
2021-01-14
14
虢國技醬
ctx, cancel := context.WithCancel(context.Background()) for i := 0; i < 30; i++ { go func(i int) { for { if isCancelled(ctx) { break } else { // fmt.Println(i, "Not Yet") } time.Sleep(time.Millisecond * 5) } fmt.Println(i, "Canceled") }(i) } go func(i int) 也可以直接利用闭包特性直接使用ctx,因为for启动多个goroutine时ctx是公用的、不变的。go func(i int) 函数启动时内部的ctx用的是外部ctx,此时内部的ctx由不确定变为确定(由开放到闭合)
2019-08-11
4
悠悠
ctx := context.Background() // ctx2 是子context ,cancel 是取消函数 ctx2, cancel := context.WithCancel(ctx) for i := 0; i < 5; i++ { go func(i int, ctx3 context.Context) { for { if isCancel(ctx3) { break } time.Sleep(time.Millisecond * 10) } fmt.Println(i, "canceled") }(i, ctx2) // 传递子context } // 然后再通过子context创建孙context ctx4, _ := context.WithCancel(ctx2) go func(ctx4 context.Context) { for { if isCancel(ctx4) { break } fmt.Println(" ctx4 canceled") } }(ctx4) cancel() time.Sleep(time.Second * 1)
2023-12-21
1
escray
Context 确实在视频中没有讲,好在老师在回复留言的时候简单的介绍了一下。我抄一段官网的文字: https://golang.org/pkg/context/ Package context defines the Context type, which carries deadlines, cancellation signals, and other request-scoped values across API boundaries and between processes. Incoming requests to a server should create a Context, and outgoing calls to servers should accept a Context. 另外有同学留言说,没有讲到什么时候使用 close 取消任务什么时候使用 context。其实在课程的开篇,老师就提到了,使用 context 为了解决层级取消的问题,就是取消一个协程的子协程(树)甚至孙子协程(树)的问题。 稍微有点可惜的是,在课程的代码中并没有演示这一部分。 https://blog.golang.org/context https://blog.golang.org/context-and-structs 以上两个链接,我也没看,不明觉厉。
2021-04-10
1
小寞子。(≥3≤)
cancel后面如果没有代码 或者waitGroup, 那么在调用后所有goroutinue也会被强制退出 并不会执行判断. 我调了半天代码才发现的。。毕竟主进程结束了 那些routine也不能独活
2021-01-06
1
1
悠悠
go func() { ctx, cancel := context.WithCancel(context.Background()) defer cancel() go func(ctx context.Context) { i := 0 for { select { case <-ctx.Done(): fmt.Printf("goroutine 2 exit") return default: fmt.Printf("goroutine 2: i = %d\n", i) time.Sleep(time.Second) i++ } } }(ctx) for j := 0; j <= 3; j++ { fmt.Printf("goroutine 1: i = %d\n", j) time.Sleep(500 * time.Millisecond) } fmt.Println("goroutine 1 exit") }() // 永远堵塞main select {} fmt.Println("Main exit")
2023-12-21
收起评论