context 使用介绍
主要功能：
- 控制超时时间
- 保存上下文数据
使用 context 处理超时
基本语法结构
import ""context""
// 生成和释放定时器
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
// 超时控制
select {
case <- ctx.Done():
// 超时时要执行的代码
default:
// 其他情况执行的代码
}
示例-访问网站超时
这里用了底层的request来发送GET请求。&http.Client{} 的结构体里本身也有 Timeout 的设置，默认的0值就是不设置超时。并且Clinet要求它的 Transport 必须实现 CancelRequest 方法，默认的 Transport 是有这个方法的。所以下面的示例就是把底层的逻辑模拟了一遍，超时后手动调用 Transport 的 CancelRequest 方法：
package main
import (
"context"
"fmt"
"os"
"io/ioutil"
"net/http"
"time"
)
type Result struct {
r *http.Response
err error
}
func process(host string) {
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel() // cancel是一个函数，执行后取消上面生成的定时器
c := make(chan Result)
tr := &http.Transport{}
client := &http.Client{Transport: tr}
req, err := http.NewRequest("GET", "http://" + host, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "HTTP GET ERROR: %v\n", err)
return
}
go func() {
resp, err := client.Do(req)
c <- Result{r: resp, err: err}
}()
select {
case <- ctx.Done():
tr.CancelRequest(req) // 取消请求
res := <- c
fmt.Println("Timeout...", res.err)
case res := <- c:
defer res.r.Body.Close()
out, _ := ioutil.ReadAll(res.r.Body) // 第二个参数是err，这里忽略错误
fmt.Printf("Server Response:\n%s\n", out)
}
return
}
func main() {
host := os.Args[1]
process(host)
}
命令行接收第一个参数作为请求的服务器地址，执行结果：
PS H:\Go\src\go_dev\day12\context> go run main.go google.com
Timeout... Get http://google.com: net/http: request canceled while waiting for connection
PS H:\Go\src\go_dev\day12\context> go run main.go baidu.com
Server Response:
<html>
<meta http-equiv="refresh" content="0;url=http://www.baidu.com/">
</html>
PS H:\Go\src\go_dev\day12\context>
一次请求超时，一次有返回结果。
使用 context 保存上下文
使用 context 还可以做一些自定的参数传递。以key-value的形式存储到 context 的变量中，用的时候再取出来。 下面的例子试了 context 来传递变量：
package main
import (
"fmt"
"context"
)
func process(ctx context.Context) {
age, ok := ctx.Value("age").(int) // 取出的值在使用之前做一下类型断言是比较好的做法
if !ok {
age = 18 // 如果有错误，就默认设置成18
}
fmt.Println("Age:", age)
name, _ := ctx.Value("name").(string) // 忽略错误
fmt.Println("Name:", name)
fmt.Println(ctx.Value("gender")) // ctx不包括也不需要类型断言，但是使用前做一下类型断言比较好
fmt.Println(ctx.Value("gender1")) // 如果没有对应的key，就返回nil
}
func main() {
ctx := context.WithValue(context.Background(), "name", "Adam") // 存的是键值对，后2个参数分别是key和value
ctx = context.WithValue(ctx, "age", 23) // 追加值，就使用之前的ctx，这样所有的值都有了
ctx = context.WithValue(ctx, "gender", "Male")
process(ctx) // 调用函数，把ctx传进去，函数里可以取出相应的值
}
这里只是演示用法，例子里的这类明确的变量，还是应该以传统的方式来传递的。那些全局需要用到的变量，可以使用 context 来进行维护。因为用了 context 之后，就把变量的信息给隐藏了，代码的可读性会变差。而且隐藏了变量的类型，也不符合go的习惯，所以上面在用之前，都在了类型断言。
使用 context 结束 goroutine
通过 context.WithCancel 方法，还可以控制goroutine的生命周期：
// 定义结束控制
ctx, cancel:= context.WithCancel(context.Background())
defer cancel()
// 执行cancel()后，ctx.Done()这个管道里就能取到值
go func() {
// 下面是一个无限循环，直到context返回，否则就一直循环下去
for {
select {
case <-ctx.Done():
return // 从管道里取到值，就退出
default:
// 其他情况执行的代码
}
}
}
这里定义了2个变量，ctx和cancel。cancel是一个可以调用的函数，调用执行后。ctx.Done这个管道就能取出一个值了。在goroutine里就可以通过这个管道来控制退出goroutine。完整示例如下：
package main
import (
"time"
"fmt"
"context"
)
func test() {
// 这是一个匿名函数的闭包，下面会调用
gen := func(ctx context.Context) <-chan int {
dst := make(chan int)
n := 1
go func() {
for {
select {
case <-ctx.Done():
fmt.Println("goroutine 结束")
return
case dst <- n:
n++
}
}
}()
return dst
}
ctx, cancel:= context.WithCancel(context.Background())
defer cancel()
for n:= range gen(ctx) {
fmt.Println(n)
if n == 5 {
break
}
}
}
func main() {
test()
time.Sleep(time.Second * 3)
fmt.Println("main 结束")
}
上面这个示例的应用场景就是：当你要启用一个goroutine执行任务，并且还需要通知这个goroutine结束的时候，就可以通过这里的 context 来实现。
DeadLine超时
WithDeadline 和 WithTimeout 是相似的。都是通过设置，会在某个时间自动触发，就是ctx.Done()能够取到值。差别是，DeadLine是设置一个时间点，时间对上了就到期。Timeout是设置一段时间，比如几秒，过个这段时间，就超时。其实底层的Timeout也是通过Deadlin实现的，在Timeout里，直接 return WithDeadline(parent, time.Now().Add(timeout))。 下面的例子设置了50毫秒超时，通过WithDeadline设置。运行程序接收一个命令行参数，传入一个整数，进过这段毫秒的时间后，会输出自定义的内容。如果数字大了（大于50），就会超时，这里会输出context的Err方法返回的信息：
package main
import (
"context"
"fmt"
"time"
"os"
"strconv"
)
func main() {
n, _ := strconv.Atoi(os.Args[1]) // 把第一个参数转成整数，忽略错误
d := time.Now().Add(50 * time.Millisecond) // 50毫秒后过期
ctx, cancel := context.WithDeadline(context.Background(), d) // 如果是Timeout，就只直接传上面Add里的部分
defer cancel()
select {
case <- time.After(time.Millisecond * time.Duration(n)): // 第一个参数小于50，进入这个分支。参数不是数字就当做0
fmt.Println("时间到了")
case <- ctx.Done():
fmt.Println(ctx.Err())
}
}
/* 执行结果
PS H:\Go\src\go_dev\day12\context\deadline> go run main.go 123
context deadline exceeded
PS H:\Go\src\go_dev\day12\context\deadline> go run main.go 12
时间到了
PS H:\Go\src\go_dev\day12\context\deadline>
*/
这个例子还是使用Timeout更方便，不过这里主要演示Deadline的用法。两个方法的效果一样，根据实际请求选择合适的方法。TImeout应该更好用，所以才会对Deadine再封装一层，提供一个Timeout方法来给更多的应用场景使用。
sync.WaitGroup 介绍
之前都是通过管道来和goroutine传递数据的，也能通过管道实现等待。不过如果只是等待goroutine执行完毕，现在还有个方法可以实现。 通过使用 sync.WaitGroup ，可以方便的等待一组goroutine结束，具体就是下面的3步：
- 使用Add方法设置等待的数量，计数加1
- 使用Done方法设置等待数量，计数减1
- 当等待数量等于0时，Wait方法返回
示例1
下面是一个发 http 请求的示例，等待所有请求返回后，才会退出主函数：
package main
import (
"os"
"sync"
"fmt"
"net/http"
)
var wg sync.WaitGroup
func main() {
var urls = []string {
"baidu.com",
"51cto.com",
"go-zh.org",
}
for _, url := range urls {
wg.Add(1) // 每开一个goroutine，计数加1
go func(url string) {
defer wg.Done() // 退出时计数减1
resp, err := http.Head("http://" + url)
if err != nil {
fmt.Fprintf(os.Stderr, "%s Head ERROR: %v", url, err)
return
}
fmt.Println(*resp)
}(url)
}
wg.Wait() // 在这里等待，所有任务完成，才继续
fmt.Println("All Requests Down")
}
示例2
下面的例子，展示另外一种风格的写法：
package main
import (
"fmt"
"sync"
"time"
)
func calc(w *sync.WaitGroup ,i int) {
defer w.Done()
fmt.Println("calc:", i)
time.Sleep(time.Second)
}
func main() {
// 另一种定义wg的方法，函数里一般用短变量声明
// 这次不是全局变量了，下面还要传参
wg := sync.WaitGroup{}
wg.Add(10) // 一次加10，不在for循环里每次加1了
for i := 0; i < 10; i++ {
go calc(&wg, i) // 结构体是值类型，用地址来传参
}
wg.Wait()
fmt.Println("All goroutine Done")
}
小结
**注意：**Add方法不能放在goroutine里面。看似没问题，不过有可能还没等goroutine运行起来，主函数就运行到Wait了。效果就是计数还没开始也就是0，主函数就可以继续执行下去了。是主函数先执行Wait还是goroutine先执行到Add就看运气了 相比管道用起来更方便也更好理解一些，而且可以等待一组goroutine。这个方法只能实现主函数等待goroutine执行结束。如果需要通知某个goroutine退出，还是要用管道来实现。管道可以用来交互数据，所以所有的情况都适用。而 sync.WaitGroup 场景比较单一，但是更好用。
