Bagaimana untuk Memaksimumkan Permintaan HTTP Serentak dalam Go?

Bagaimanakah untuk "Maksimumkan" Permintaan HTTP Serentak dengan Berkesan?

Apabila bereksperimen dengan prestasi Go, anda mungkin menghadapi had semasa cuba melaksanakan jumlah permintaan HTTP yang tinggi secara serentak . Artikel ini meneroka cabaran yang dihadapi dan menyediakan penyelesaian untuk mencapai keselarasan maksimum.

Masalahnya

Pendekatan awal anda melibatkan pelancaran sejumlah besar goroutine untuk menghantar permintaan HTTP secara selari, menjangkakan ia akan digunakan semua CPU yang ada. Walau bagaimanapun, anda menghadapi ralat disebabkan oleh had deskriptor fail.

Penyelesaian

Untuk mengatasi had ini, pertimbangkan pendekatan berikut:

• Gunakan sempadan saluran semaphore untuk mengawal konkurensi: Laksanakan saluran buffer yang berfungsi sebagai semaphore, mengehadkan bilangan permintaan serentak. Dengan melaraskan saiz penimbal saluran dan menala GOMAXPROCS, anda boleh mengoptimumkan konkurensi untuk sistem anda.
• Manfaatkan kumpulan pekerja dengan penghantar: Gunakan corak kumpulan pekerja yang permintaan akan dibariskan ke dalam saluran . Seorang penghantar mengisi saluran, manakala sekumpulan pekerja memproses permintaan satu demi satu. Pendekatan ini memastikan bilangan maksimum permintaan serentak dikekalkan.
• Gunakan goroutin pengguna khusus untuk memproses respons: Untuk mengelak daripada menyekat pemprosesan permintaan, gunakan goroutine khusus untuk menggunakan respons daripada pekerja kolam. Ini memastikan pelaksanaan permintaan berterusan, membolehkan sistem anda mengendalikan lebih banyak permintaan serentak.

Kod Dioptimumkan

Berikut ialah versi diubah suai kod anda yang menggabungkan pengoptimuman ini:

package main

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

var (
    reqs       int
    concurrent int
    work       chan *http.Request
    results    chan *http.Response
)

func init() {
    reqs = 1000000
    concurrent = 200
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    work = make(chan *http.Request, concurrent)
    results = make(chan *http.Response)
    start := time.Now()

    // Create a semaphore channel to limit concurrency
    sem := make(chan struct{}, concurrent)

    // Create a dispatcher to populate the work channel
    go func() {
        for i := 0; i < reqs; i++ {
            req, _ := http.NewRequest("GET", "http://localhost/", nil)
            work <- req
        }
        close(work) // Signal to workers that no more requests are incoming
    }()

    // Create a worker pool to process requests
    for i := 0; i < concurrent; i++ {
        go func() {
            for req := range work {
                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                    fmt.Println(err)
                }
                results <- resp

                // Release semaphore token to allow another worker to proceed
                <-sem
            }
        }()
    }

    // Consume responses from worker pool
    var (
        conns int64
        totalSize int64
        wg     sync.WaitGroup
    )

    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            select {
            case resp, ok := <-results:
                if ok {
                    conns++
                    totalSize += resp.ContentLength
                    resp.Body.Close()
                } else {
                    return
                }
            }
        }
    }()

    // Block until all responses are processed
    wg.Wait()

    elapsed := time.Since(start)
    fmt.Printf("Connections:\t%d\nConcurrent:\t%d\nTotal size:\t%d bytes\nElapsed:\t%s\n", conns, concurrent, totalSize, elapsed)
}

Dengan melaraskan pembolehubah serentak dan memerhatikan keputusan, anda boleh menentukan tahap serentak optimum untuk sistem anda, "memaksimumkan" kapasitinya untuk permintaan HTTP serentak.

Atas ialah kandungan terperinci Bagaimana untuk Memaksimumkan Permintaan HTTP Serentak dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!