내 노트북이 Go를 사용하여 백만 개의 동시 HTTP 요청을 처리할 수 있나요?

당신의 노트북이 백만 개의 동시 HTTP 요청을 처리할 수 있습니까?

REST API 서비스에 1,000,000개의 동시 HTTP 요청을 보내 컴퓨터의 한계를 뛰어 넘는다고 상상해 보십시오. 동시성을 극대화합니다. 이 작업을 위한 도구가 있지만 Go에서 고루틴을 사용하여 이를 수행하는 방법을 살펴보겠습니다.

package main

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

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU()) // Use all available CPU cores
    transport := &http.Transport{}        // Create an HTTP transport

    for i := 0; i < 1000000; i++ {
        go func() { // Start a goroutine for each HTTP request
            req, _ := http.NewRequest("GET", "http://myapi.com", nil)
            req.Header.Set("User-Agent", "custom-agent")
            req.SetBasicAuth("xxx", "xxx")

            resp, err := transport.RoundTrip(req)
            if err != nil {
                panic("HTTP request failed.")
            }
            defer resp.Body.Close()

            if resp.StatusCode != 302 {
                panic("Unexpected response returned.")
            }

            location := resp.Header.Get("Location")
            if location == "" {
                panic("No location header returned.")
            }

            fmt.Println("Location Header Value:", location)
        }()
    }

    time.Sleep(60 * time.Second) // Sleep for 60 seconds
}

하지만 잠깐, 문제가 있습니다!

이 스크립트 실행하기 파일 설명자 제한으로 인해 오류가 발생합니다. 시스템은 너무 많은 동시 연결을 처리할 수 없습니다.

향상된 솔루션

이러한 한계를 극복하려면 보다 정교한 접근 방식을 사용해야 합니다.

배치자 및 작업자 풀 사용

이 솔루션에는 요청을 채널에 푸시하는 디스패처 고루틴. 고루틴의 작업자 풀은 채널에서 요청을 가져와 처리한 후 응답 채널로 보냅니다. 그런 다음 소비자 고루틴이 응답을 처리합니다.

// Dispatcher function
func dispatcher(reqChan chan *http.Request, reqs int) {
    defer close(reqChan)
    for i := 0; i < reqs; i++ {
        req, err := http.NewRequest("GET", "http://localhost/", nil)
        if err != nil {
            log.Println(err)
        }
        reqChan <- req
    }
}

// Worker function
func worker(t *http.Transport, reqChan chan *http.Request, respChan chan Response) {
    for req := range reqChan {
        resp, err := t.RoundTrip(req)
        r := Response{resp, err}
        respChan <- r
    }
}

// Consumer function
func consumer(respChan chan Response, reqs int) (int64, int64) {
    var (
        conns int64
        size  int64
    )
    for conns < int64(reqs) {
        select {
        case r, ok := <-respChan:
            if ok {
                if r.err != nil {
                    log.Println(r.err)
                } else {
                    size += r.ContentLength
                    if err := r.Body.Close(); err != nil {
                        log.Println(r.err)
                    }
                }
                conns++
            }
        }
    }
    return conns, size
}

결과

이 향상된 스크립트를 실행하면 다음과 같은 인상적인 결과가 생성됩니다.

연결: 1000000

동시: 200

총 크기: 15000000바이트

총 시간: 38분20.3012317초

평균 시간: 2.280131ms

성능 최적화

그러나 동시 요청 수와 총 요청 수를 조정하면 푸시하는 데 도움이 됩니다. 시스템의 한계를 확인하고 성능을 스트레스 테스트해 보세요. 이는 극단적인 테스트이며 시스템 리소스를 빠르게 소모할 수 있다는 점을 기억하세요.

위 내용은 내 노트북이 Go를 사용하여 백만 개의 동시 HTTP 요청을 처리할 수 있나요?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!