Go处理超时的最简单方法

【译文】原文地址

任何处理资源密集型的应用程序，超时处理是不可避免的。检查超时是有必要的，以确保超时运行的任务不会消耗应用程序的其他组件可能需要的必要资源或网络带宽。

Golang处理超时的方法非常简单。不需要复杂的代码，我们可以用channel通信和使用select语句作出超时决策来处理超时问题。

首先，最基本的。要模拟网络连接，我们将从一个模拟的服务中读取响应。我们编写一个简单结构体来接收服务的响应内容。

type Response struct {
    UserID    int    `json:"userId"`
    ID        int    `json:"id"`
    Title     string `json:"title"`
    Completed bool   `json:"completed"`
}

直截了当地，我们将写一个快速方法来获取服务中的响应，并将其返回给客户端。

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func GetHttpResponse() (*Response, error) {
    resp, err := http.Get("https://jsonplaceholder.typicode.com/todos/1")

    if err != nil {
        return nil, fmt.Errorf("error in http call")
    }

    defer resp.Body.Close()
    byteResp, err := ioutil.ReadAll(resp.Body)

    if err != nil {
        return nil, fmt.Errorf("error in reading response")
    }

    structResp := &Response{}
    err = json.Unmarshal(byteResp, structResp)

    if err != nil {
        return nil, fmt.Errorf("error in unmarshalling response")
    }

    return structResp, nil
}

如您所见，这是一个非常简单的方法。我们仅使用Golang原生http库读取http调用中的信息，并将响应内容存放在out结构体中，在不同的步骤中处理错误。非常简单！

我们的main函数可以很简单地调用这个函数，并打印服务响应信息。

import (
    "fmt"
)
func main() {

    res, err := GetHttpResponse()

    if err != nil {
        fmt.Printf("err %v", err)
    } else {
        fmt.Printf("res %v", res)
    }

}

结果输出了一个来自模拟服务的虚拟响应信息如下：

res &{1 1 delectus aut autem false}

现在来看存在的问题，假设您的连接需要很长时间才能从模拟的服务器中获得响应，那么我们的main函数将等待不确定时间。在实际应用程序中，这是不可接受的，因为这会消耗很多资源。要解决这个问题，让我们在GetHttpResponse函数中添加一个context参数。

func GetHttpResponse(ctx context.Context) (*Response, error)

这个context将告我们何时停止尝试从网络中获取结果。为了验证这点，我们将使用select语句。Select语句是go中处理并发的默认方式，包含发送和接收channel的case。语法和switch类似。

我们先编写一个帮助函数，执行和前面相同的操作，返回结果，并将结果写入channel，并使用一个独立的goroutine来执行实际工作。为了简单起见，我们还将响应和错误包装在一个CallResponse结构体中。

type CallResponse struct {
    Resp *Response
    Err  error
}

func helper(ctx context.Context) <-chan *CallResponse {

    respChan := make(chan *CallResponse, 1)

    go func() {
        resp, err := http.Get("https://jsonplaceholder.typicode.com/todos/1")

        if err != nil {
            respChan <- &CallResponse{nil, fmt.Errorf("error in http call")}
            return
        }

        defer resp.Body.Close()
        byteResp, err := ioutil.ReadAll(resp.Body)

        if err != nil {
            respChan <- &CallResponse{nil, fmt.Errorf("error in reading response")}
            return
        }

        structResp := &Response{}
        err = json.Unmarshal(byteResp, structResp)

        if err != nil {
            respChan <- &CallResponse{nil, fmt.Errorf("error in unmarshalling response")}
        }

        respChan <- &CallResponse{structResp, nil}
    }()

    return respChan
}

如代码所示，我们创建了一个带缓存的respChan通道。然后我们执行和GetHttpResponse函数相同的工作，但是我们用一个CallResponse来代替返回响应和错误。我们在函数结束返回resChan。我们在单独的goroutine中执行网络连接，并将结果写入channel。这使我们的代码实现非阻塞。

我们的GetHttpResponse函数现在变的更简单了，因为它必须做一个简单的选择。要么从通道中读取响应要么超时退出。

func GetHttpResponse(ctx context.Context) (*Response, error) {
    select {
    case <-ctx.Done():
        return nil, fmt.Errorf("context timeout, ran out of time")
    case respChan := <-helper(ctx):
        return respChan.Resp, respChan.Err

    }
}

这个选择策略是通过select语句来完成的。以下是Done函数的定义：

Done() <-chan struct{}

Done返回一个channel，当涉及的context被取消，channel就会关闭。当context中有超时，就会在超时时对通道进行写操作。在这种情况下，代码返回一个表示超时的错误响应信息。

另一个case是，我们的helper函数能够在超时之前完成服务的响应读取，并写入channel。在这种情况下，我们在respChan变量中得到结果，并返回给客户端。

下面修改main函数，调用GetHttpResponse并传入一个1秒超时的context参数。

ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel()
    res, err := GetHttpResponse(ctx)

    if err != nil {
        fmt.Printf("err %v", err)
    } else {
        fmt.Printf("res %v", res)
    }

}

运行上面代码可以得到和之前相同的响应信息：

res &{1 1 delectus aut autem false}

现在，我们将超时减少到1毫秒，以观察代码执行结果：

ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond)

当我们运行代码时，我们得到如下结果：

err context timeout, ran out of time

1毫秒内不足以完成网络调用。因此我们不会过多占用任何资源，而且只要context超时，我们就向客户端返回错误，而不是一直等待响应。

---