关闭通道以避免超时

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，编程网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《关闭通道以避免超时》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我有一个小型 go 程序，它每个周期（1 秒）都会发出多个请求。我正在尝试同时提出这些请求。我想计算并记录一次成功请求的数量，然后继续。如果请求没有及时完成，我不想阻止主代码。

下面的代码实现了这一点，但我不相信我正确地关闭了并发请求中的通道。因为任何错过截止日期的请求仍会使用前一个刻度进行记录。我还相信主函数中的代码会阻塞等待并发请求完成。我尝试将 close(ch) 移动到我的选择中的超时情况内，但这会导致“在关闭通道上发送”错误。

我的理解是，使用带有截止日期的上下文（可能在我的主代码中设置）可能是一个解决方案，但我正在努力理解它们，我想知道是否还有其他我可以尝试的方法。

注意：concurrentreqs 中的超时故意设置得很低，因为我是在本地测试的。

package main

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

type response struct {
    num int
    statusCode int
    requestDuration time.Duration
}

func singleRequest(url string, i int, tick int) response {
    start := time.Now()
    client := http.Client{ Timeout: 100 * time.Millisecond }

    resp, _ := client.Get(url)
    fmt.Printf("%d: %d\n", tick, i)

    defer resp.Body.Close()

    return response{statusCode: int(resp.StatusCode), requestDuration: time.Since(start)}
}

func concurrentReqs(url string, reqsPerTick int, tick int) (results []response){
    ch := make(chan response, reqsPerTick)
    timeout := time.After(20 * time.Millisecond) // deliberately low
    results = make([]response, 0)

    for i := 0; i < reqsPerTick; i++ {
        go func(i int, t int) {
            ch <- singleRequest(url, i, tick)
        }(i, tick)
    }

    for i := 0; i < reqsPerTick; i++ {
        select {
        case response := <- ch:
            results = append(results, response)
        case <- timeout:
            return
        }
    }
    close(ch)

    return
}

func main() {
    var url string = "http://end-point.svc/req"

    c := time.Tick(1 * time.Second)
    for next := range c {
        things := concurrentReqs(url, 100, next.Second())
        fmt.Printf("%s: Successful Reqs - %d\n", int(next.Second()), len(things))
    }
}

解决方案

我建议使用带有超时的上下文来取消和超时。另外，我认为使用等待组和互斥锁保护的结果写入可以通过消除第二个循环来帮助简化。

package main

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

type response struct {
    num             int
    statusCode      int
    requestDuration time.Duration
}

func singleRequest(ctx context.Context, url string, i int, tick int) (response, error) {
    start := time.Now()

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return response{requestDuration: time.Since(start)}, err
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return response{requestDuration: time.Since(start)}, err
    }

    fmt.Printf("%d: %d\n", tick, i)

    defer resp.Body.Close()

    return response{statusCode: int(resp.StatusCode), requestDuration: time.Since(start)}, nil
}

func concurrentReqs(url string, reqsPerTick int, tick int) (results []response) {
    mu := sync.Mutex{}
    results = make([]response, 0)

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

    wg := sync.WaitGroup{}
    for i := 0; i < reqsPerTick; i++ {
        wg.Add(1)
        go func(i int, t int) {
            defer wg.Done()
            response, err := singleRequest(ctx, url, i, tick)
            if err != nil {
                log.Print(err)
                return
            }
            mu.Lock()
            results = append(results, response)
            mu.Unlock()
        }(i, tick)
    }

    wg.Wait()

    return results
}

func main() {
    var url string = "http://end-point.svc/req"

    c := time.Tick(1 * time.Second)
    for next := range c {
        // You may want to wrap this in a goroutine to make sure tick is not skipped.
        // Otherwise if concurrentReqs takes more than a tick time for whatever reason, a tick will be skipped.
        things := concurrentReqs(url, 100, next.Second())
        fmt.Printf("%s: Successful Reqs - %d\n", int(next.Second()), len(things))
    }
}

到这里，我们也就讲完了《关闭通道以避免超时》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注编程网公众号，带你了解更多关于的知识点！