为何HTTP请求总是花费与完全超时相同的时间？

HTTP 请求的完成时间与完全超时时间相等的原因在于，并行请求的等待方式。当并发发出多个请求时，程序会等待所有请求完成，即使其中一些请求已成功返回。因此，如果最慢的请求超时时间较长，则程序将等待整个超时时间，即使其他请求已完成。此外，请求的数量不会影响等待时间，因为所有请求都是并行执行的。

我正在制作一个 _golang git bruteforcer。它的行为有点奇怪，我想这与并发有关。 sync.waitgroup

这是代码：https://dpaste.org/vo7y

package main

import {  }

// ReadFile : Reads File and returns it's contents
func ReadFile(fileName string) []string {  }

func joinString(strs ...string) string {  }

// MakeRequest : Makes requests concurrently
func MakeRequest(client *http.Client, url string, useragent string, ch chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()
    // start := time.Now()
    request, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    request.Header.Set("User-Agent", useragent)
    response, err := client.Do(request)
    if err != nil {
        return
    }
    // secs := time.Since(start).Seconds()
    if response.StatusCode < 400 {
        // fmt.Printf("Time elapsed %f", secs)
        bodyBytes, err := ioutil.ReadAll(response.Body)
        if err != nil {
            log.Fatal(err)
        }
        defer response.Body.Close()
        bodyString := string(bodyBytes)
        notGit, err := regexp.MatchString("", strings.ToLower(bodyString))
        if !notGit && len(bodyString) > 0 { // empty pages and html pages shouldn't be included
            fmt.Println(bodyString)
            ch <- fmt.Sprintf(" %s ", Green(url))
        }
    }
}

func main() {
    start := time.Now()
    useragent := "Mozilla/10.0 (Windows NT 10.0) AppleWebKit/538.36 (KHTML, like Gecko) Chrome/69.420 Safari/537.36"
    gitEndpoint := []string{"/.git/", "/.git/HEAD", "/.gitignore", "/.git/description", "/.git/index"}
    timeout := 10 * time.Second
    var tr = &http.Transport{
        MaxIdleConns:      30,
        IdleConnTimeout:   time.Second,
        DisableKeepAlives: true,
        TLSClientConfig:   &tls.Config{InsecureSkipVerify: true},
        DialContext: (&net.Dialer{
            Timeout:   timeout,
            KeepAlive: time.Second,
        }).DialContext,
    }
    re := func(req *http.Request, via []*http.Request) error {
        return http.ErrUseLastResponse
    }
    client := &http.Client{
        Transport:     tr,
        CheckRedirect: re,
        Timeout:       timeout,
    }
    output := ReadFile(os.Args[1])
    // start := time.Now()
    ch := make(chan string)
    var wg sync.WaitGroup
    for _, url := range output {
        for _, endpoint := range gitEndpoint {
            wg.Add(1)
            go MakeRequest(client, "https://"+url+endpoint, useragent, ch, &wg)
        }
    }
    go func() {
        wg.Wait()
        close(ch)
    }()
    f, err := os.OpenFile("git_finder.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    for val := range ch {
        if err != nil {
            fmt.Println(Red(err))
        }
        _, err = fmt.Fprintln(f, val)
        fmt.Println(val)
    }
    f.Close()
    fmt.Printf("Total time taken %.2fs elapsed\n", time.Since(start).Seconds())
}

工作：

它从文件中读取 url，并检查网络服务器上的 /.git、/.git/head、/.git/description、/.git/index。

问题： 如果我将 http.client 超时更改为 2 秒 它将在 2 秒内完成，如果是 50 秒，它将等待 50 秒，输入文件是否包含 10 个 url 或 500 个 url 并不重要。 我的理解是，如果有更多的 url，它将等待，直到 goroutine 传递的最后一个 url 超时。

更新 1：

正如阿德里安在评论中提到的，它看起来不像是并发问题，这就是主要问题之一，我无法确定到底是什么问题

解决方案

在代码中，您从文件中读取 URL，然后并行向所有这些 URL 发出请求，然后等待所有并行请求完成。

所以这实际上是有道理的，并不表明存在问题：

如果我将 http.Client 超时更改为 2 秒，它将在 2 秒内完成，如果是 50 秒，它将等到 50 秒，输入文件是否包含 10 个 url 或 500 个 url 并不重要。 p>

假设您的文件有 500 个网址。

您并行触发 500 个请求...然后等待所有请求完成（请记住，它们都是并行执行的）。需要多长时间？

在最坏的情况下（所有请求在 50 秒超时），总共只需要 50 秒（因为它们都在并行等待这 50 秒）。

在最好的情况下（所有请求都成功通过且没有超时），应该需要几秒钟。

在一般情况下，您可能会看到（在 50 秒处出现几次超时），然后需要 50 秒（在最坏的情况下，您将等待这几个请求并行等待这 50 秒）。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《为何HTTP请求总是花费与完全超时相同的时间？》文章吧，也可关注golang学习网公众号了解相关技术文章。