我在 Go 中有以下基本的 http 服务器。对于每个传入请求，它都会发布 5 个传出 http 请求。他们每个人大约需要 3-5 秒。我无法在 8 gig Ram、四核机器上达到超过 200 个请求/秒。

package main

import (
    "flag"
    "fmt"
    "net/http"
    _"net/url"
    //"io/ioutil"
    "time"
    "log"
    "sync"
    //"os"
    "io/ioutil"
)

// Job holds the attributes needed to perform unit of work.
type Job struct {
    Name  string
    Delay time.Duration
}

func requestHandler(w http.ResponseWriter, r *http.Request) {
    // Make sure we can only be called with an HTTP POST request.
    fmt.Println("in request handler")
    if r.Method != "POST" {
        w.Header().Set("Allow", "POST")
        w.WriteHeader(http.StatusMethodNotAllowed)
        return
    }

    // Set name and validate value.
    name := r.FormValue("name")
    if name == "" {
        http.Error(w, "You must specify a name.", http.StatusBadRequest)
        return
    }

    delay := time.Second * 0

    // Create Job and push the work onto the jobQueue.
    job := Job{Name: name, Delay: delay}
    //jobQueue <- job

    fmt.Println("creating worker")
    result := naiveWorker(name, job)
    fmt.Fprintf(w, "your task %s has been completed ,here are the results : %s", job.Name, result)

}

func naiveWorker(id string, job Job) string {
    var wg sync.WaitGroup
    responseCounter := 0;
    totalBodies := "";
    fmt.Printf("worker%s: started %s\n", id, job.Name)

    var urls = []string{
        "https://someurl1",
        "https://someurl2",
        "https://someurl3",
        "https://someurl4",
        "https://someurl5",
    }

    for _, url := range urls {
        // Increment the WaitGroup counter.

        wg.Add(1)
        // Launch a goroutine to fetch the URL.
        go func(url string) {

            // Fetch the URL.
            resp, err := http.Get(url)
            if err != nil {
                fmt.Printf("got an error")
                //  panic(err)

            } else {
                defer resp.Body.Close()
                body, err := ioutil.ReadAll(resp.Body)
                if err != nil {
                    totalBodies += string(body)
                }
            }
            responseCounter ++
            // Decrement the counter when the goroutine completes.
            defer wg.Done()

        }(url)
    }
    wg.Wait()
    fmt.Printf("worker%s: completed %s with %d calls\n", id, job.Name, responseCounter)
    return totalBodies
}

func main() {
    var (
        port = flag.String("port", "8181", "The server port")
    )
    flag.Parse()

    // Start the HTTP handler.
    http.HandleFunc("/work", func(w http.ResponseWriter, r *http.Request) {
        requestHandler(w, r)
    })
    log.Fatal(http.ListenAndServe(":" + *port, nil))
}

我有以下问题:

1. 当并发线程数超过 1000 时，http 连接会重置。这是可接受的/预期的行为吗？

2. 如果我写 go requestHandler(w,r) 而不是 requestHandler(w,r) 我得到 http: 多次响应.WriteHeader 调用

最佳答案

http 处理程序应该同步运行，因为处理程序函数的返回表示请求结束。在处理程序返回后访问 http.Request 和 http.ResponseWriter 是无效的，因此没有理由在 goroutine 中调度处理程序。

正如评论所指出的，您不能打开比进程 ulimit 允许的更多的文件描述符。除了适当增加 ulimit 之外，您还应该限制一次可以分派(dispatch)的并发请求数。

如果您要与同一主机建立多个连接，您还应该相应地调整您的 http.Transport。每个主机的默认空闲连接只有 2 个，因此如果您需要超过 2 个到该主机的并发连接，新连接将不会被重用。参见 Go http.Get, concurrency, and "Connection reset by peer"

如果您连接到许多不同的主机，设置 Transport.IdleConnTimeout 是摆脱未使用的连接的好主意。

和往常一样，在长时间运行的服务中，您需要确保为所有内容设置超时，这样缓慢或中断的连接就不会占用不必要的资源。

关于go - Go中的有限并发连接，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47385692/