美文网首页
go context解析

go context解析

作者: zooeymoon | 来源:发表于2020-04-07 23:59 被阅读0次

    上下文context

    描述

    上下文context是1.7引进到标准库的包。官方的解释为：

    Package context defines the Context type, which carries deadlines, cancellation signals, and other request-scoped values across API boundaries and between processes.

    大致的意思是：

    context包定义了Context类型，这个类型含有截止时间，取消信号和在进程中和跨api边界的其他跨域请求

    context.Context类型接口需要实现4个方法:

    1. Deadline — 返回 context.Context 被取消的时间，也就是完成工作的截止日期；
    2. Done — 返回一个 Channel，这个 Channel 会在当前工作完成或者上下文被取消之后关闭，多次调用 Done 方法会返回同一个 Channel；
    3. Err — 返回 context.Context 结束的原因，它只会在 Done 返回的 Channel 被关闭时才会返回非空的值；
      如果 context.Context 被取消，会返回 Canceled 错误；
      如果 context.Context 超时，会返回 DeadlineExceeded 错误；
    4. Value — 从 context.Context 中获取键对应的值，对于同一个上下文来说，多次调用 Value 并传入相同的 Key 会返回相同的结果，该方法可以用来传递请求特定的数据；
    type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}

    context的设计的初衷是为了通过同步信号实现对goroutines的树结构进行信号同步，这样可以最大程度的减少对计算资源的浪费。

    Go 服务的每一个请求的都是通过单独的 Goroutine 处理的，HTTP/RPC 请求的处理器会启动新的 Goroutine 访问数据库和其他服务。

    代码讲解

    代码入门

    这里我们先走一个简单的事例：

    首先我们创建一个方法sleepAndTalk，这个方法会在5秒钟后输出字符串，或者如果context关闭，则打印错误信息

    func sleepAndTalk(ctx context.Context, duration time.Duration, s string) {

    select {
    case <-ctx.Done():
        fmt.Println("handle", ctx.Err())

    case <-time.After(duration):
        fmt.Println(s)
    }
}

    接下来我们在main方法里面调用这个方法,创建一个context.Background同时使用context.WithCancel(ctx)方法
    ，同时开启一个协程用来扫描输入信号，如果在5秒中内有键盘输入，则出发cancel方法

    func main() {

    ctx := context.Background()

    ctx , cancel := context.WithCancel(ctx)


    go func() {
        s := bufio.NewScanner(os.Stdin)
        s.Scan()
        cancel()
    }()

    sleepAndTalk(ctx, time.Second*5, "hello")

}

    貌似这里我们感觉不太爽，我们应该修改为1秒钟之后让其触发cancel方法，修改代码为:

    func main() {

    ctx := context.Background()

    ctx, cancel := context.WithTimeout(ctx, time.Second)
    defer cancel()

    sleepAndTalk(ctx, time.Second*5, "hello")

}

    我们这一次把代码修改为在main中等待一秒中之后触发cancel方法。

    http中使用context

    首先我们创建两个文件夹：一个server和一个client，分别处理http的服务端和客户端的请求

    在server文件夹下创建一个server.go，这里我们模拟一下请求很慢的操作，让其等待5秒钟后返回值

    package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe("127.0.0.1:8080", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {

    log.Println("handler started")
    defer log.Println("handler stopped")

    time.Sleep(time.Second * 5)
    fmt.Fprintln(w , "hello world")
}

    在client文件夹下我们创建一个client.go文件来处理服务端返回的请求

    package main

import (
    "io"
    "log"
    "net/http"
    "os"
)

func main() {

    r ,err := http.Get("http://localhost:8080")
    if err != nil {
        log.Fatal(err.Error())
    }
    defer r.Body.Close()
    if r.StatusCode != http.StatusOK {
        log.Fatal(r.Status)
    }

    io.Copy(os.Stdout , r.Body)
}

    当我们运行代码时，出现的效果为5秒钟后返回hello world

    ➜  server git:(master) ✗ go run server.go
2020/04/07 00:30:30 handler started
2020/04/07 00:30:35 handler stopped

    ➜  ~ curl 127.0.0.1:8080
hello world

    现在我们需要把context加入到服务端中，在server.go文件中context隐藏在r *http.Request中，我们可以调用r.Context()返回context。之后使用select语句处理请求

    修改的server.go文件：

    package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe("127.0.0.1:8080", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {

    ctx := r.Context()

    log.Println("handler started")
    defer log.Println("handler stopped")
    select {
    case <-time.After(5 *time.Second):
        fmt.Fprintln(w , "hello world")
    case <-ctx.Done():
        err := ctx.Err()
        log.Print(err)
        http.Error(w , err.Error(),http.StatusInternalServerError)
    }

}

    当我们运行这段代码时，不需要等待5秒钟强行把请求关闭,则在终端会输出取消

    ➜  server git:(master) ✗ go run server.go
2020/04/07 00:58:30 handler started
2020/04/07 00:58:31 context canceled
2020/04/07 00:58:31 handler stopped

    那么我们如何在client中使用context呢？

    这里我们需要创建一个新的http.NewRequest()请求，之后创建一个context，把context包含到请求中

    package main

import (
    "context"
    "io"
    "log"
    "net/http"
    "os"
)

func main() {

    ctx := context.Background()
    req , err := http.NewRequest(http.MethodGet , "http://localhost:8080" , nil)
    if err != nil {
        log.Fatal(err)
    }

    req = req.WithContext(ctx)

    res ,err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err.Error())
    }
    defer res.Body.Close()
    if res.StatusCode != http.StatusOK {
        log.Fatal(res.Status)
    }

    io.Copy(os.Stdout , res.Body)
}

    这时候我们在运行代码，在一秒钟之后强制退出

    终端会打印：

    ➜  server git:(master) ✗ go run server.go
2020/04/07 01:09:53 handler started
2020/04/07 01:09:58 handler stopped
2020/04/07 01:10:10 handler started
2020/04/07 01:10:10 context canceled
2020/04/07 01:10:10 handler stopped

    可以在真是的场景里，可能用户会因为等待时间过长，而取消请求，这时候我们需要在client.go使用withTimeout方法来模拟服务器处理时间太长导致用户失去耐心，取消请求

    package main

import (
    "context"
    "io"
    "log"
    "net/http"
    "os"
    "time"
)

func main() {

    ctx := context.Background()

    ctx, cancel := context.WithTimeout(ctx, time.Second)
    defer cancel()
    req, err := http.NewRequest(http.MethodGet, "http://localhost:8080", nil)
    if err != nil {
        log.Fatal(err)
    }

    req = req.WithContext(ctx)

    res, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err.Error())
    }
    defer res.Body.Close()
    if res.StatusCode != http.StatusOK {
        log.Fatal(res.Status)
    }

    io.Copy(os.Stdout, res.Body)
}

    一秒钟之后，客户端终端会打印context取消的错误信息

    2020/04/07 01:15:30 Get "http://localhost:8080": context deadline exceeded

    context传递value

    理论上不推荐在context中传递value，因为可能会导致系统不可控。在真正使用传值的功能时我们也应该非常谨慎，使用 context.Context进行传递参数请求的所有参数一种非常差的设计，比较常见的使用场景是传递请求对应用户的认证令牌以及用于进行分布式追踪的请求 ID。

    下面我们创建一个log文件夹，创建一个log.go文件，这个文件的主要作用是打印日志，把context引用到print方法中。同时创建一个Decorate方法，重写handlerfunc方法，在请求的request中添加context.withValue产生一个随机数，让Println方法中打印这个随机数

    log.go代码:

    package log

import (
    "context"
    "log"
    "math/rand"
    "net/http"
)

const RequestIDKey = 42

func Println(ctx context.Context , msg string) {

    id, ok := ctx.Value(RequestIDKey).(int64)
    if !ok {
        log.Println("could not find request ID in context")
    }

    log.Printf("[%d] %s" , id , msg)
}

func Decorate(f http.HandlerFunc) http.HandlerFunc {

    return func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        id := rand.Int63()
        ctx = context.WithValue(ctx , RequestIDKey , id)
        f(w , r.WithContext(ctx))
    }
}

    下面修改server文件夹下的main.go文件,修改handlefunc。

    package main

import (
    "fmt"
    "github.com/my/repo/concurrency/context/log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/", log.Decorate(handler))
    panic(http.ListenAndServe("127.0.0.1:8080", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {

    ctx := r.Context()

    log.Println(ctx, "handler started")
    defer log.Println(ctx, "handler stopped")
    select {
    case <-time.After(5 * time.Second):
        fmt.Fprintln(w, "hello world")
    case <-ctx.Done():
        err := ctx.Err()
        log.Println(ctx, err.Error())
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }

}

    重新启动服务端，会发现后台输出随机数字和传递的字符串

    ➜  server git:(master) ✗ go run server.go
2020/04/07 22:32:22 [5577006791947779410] handler started
2020/04/07 22:32:23 [5577006791947779410] context canceled
2020/04/07 22:32:23 [5577006791947779410] handler stopped

    我们现在需要考虑一下这个问题，如果RequestIDKey值被重新设置了，这样的话我们可能不会生成一个随机数

    package main

import (
    "context"
    "fmt"
    "github.com/my/repo/concurrency/context/log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/", log.Decorate(handler))
    panic(http.ListenAndServe("127.0.0.1:8080", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {

    ctx := r.Context()
    ctx = context.WithValue(ctx , int(42) , int64(100))
    log.Println(ctx, "handler started")
    defer log.Println(ctx, "handler stopped")
    select {
    case <-time.After(5 * time.Second):
        fmt.Fprintln(w, "hello world")
    case <-ctx.Done():
        err := ctx.Err()
        log.Println(ctx, err.Error())
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }

}

    这里我们设置了

    ctx = context.WithValue(ctx , int(42) , int64(100))

    这时输出的结果为

    ➜  server git:(master) ✗ go run server.go
2020/04/07 23:18:20 [100] handler started
2020/04/07 23:18:21 [100] context canceled
2020/04/07 23:18:21 [100] handler stopped

    我们如果防止RequestIDKey 被篡改呢？其实我们可以对这个常量设置类型，让其阻断修改

    package log

import (
    "context"
    "log"
    "math/rand"
    "net/http"
)

type key int

const RequestIDKey = key(42)

func Println(ctx context.Context , msg string) {

    id, ok := ctx.Value(RequestIDKey).(int64)
    if !ok {
        log.Println("could not find request ID in context")
    }

    log.Printf("[%d] %s" , id , msg)
}

func Decorate(f http.HandlerFunc) http.HandlerFunc {

    return func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        id := rand.Int63()
        ctx = context.WithValue(ctx , RequestIDKey , id)
        f(w , r.WithContext(ctx))
    }
}

    这里我们设置了一个类型key为int类型，这样这个key类型只能在log.go文件里面使用，这样几可以阻止外部对其的修改
    这回我们的输出结果为：

    ➜  server git:(master) ✗ go run server.go
2020/04/07 23:52:45 [5577006791947779410] handler started
2020/04/07 23:52:46 [5577006791947779410] context canceled
2020/04/07 23:52:46 [5577006791947779410] handler stopped

    参考文献：

    1. Go 语言并发编程与 Context
    2. justforfunc #9: The Context Package

    相关文章

      网友评论

          本文标题：go context解析

          本文链接：https://www.haomeiwen.com/subject/zvbaphtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|go context解析|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！