golang 同時リクエスト

最新の Web アプリケーションでは、ネットワーク リクエストは重要な部分です。ネットワークリクエストを使用すると、データを簡単に取得および送信できます。ただし、アプリケーションのサイズが増加し続けると、リクエストの数も増加します。この場合、システムの安定性と効率性をどのように確保するかが特に重要になります。

Go 言語は、優れたメモリ管理と同時実行制御を備えた効率的な同時プログラミング言語であるため、大量の同時リクエストの処理に優れています。この記事では、Go 言語を使用して同時リクエストを処理する方法を紹介します。

1. リクエストの同時処理

一般に、ネットワーク リクエストは、接続の確立、リクエストの送信、応答の受信という 3 つのステップで構成されます。従来のアプリケーションでは、各リクエストは次の 3 つのステップを経て処理されます。ただし、同時実行性の高いアプリケーションでは、各リクエストは実行を開始する前に前のリクエストが完了するまで待機する必要があるため、このアプローチは非効率的です。

ここでは別のアプローチを紹介します。 Go 言語の同時実行機能を使用して複数のリクエストを同時に実行できるため、アプリケーションは複数のリクエストを同時に処理できます。

これは簡単なサンプル コードです:

func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    ch := make(chan string)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

func fetch(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprint(err)
        return
    }
    defer resp.Body.Close()

    text, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- fmt.Sprint(err)
        return
    }

    ch <- fmt.Sprintf("url:%s, body:%s", url, text[:100])
}

この例では、複数の URL を含むスライスを定義します。次に、バッファリングされたチャネルを作成し、go キーワードを使用して goroutine を開始し、各リクエストを同時に処理します。 goroutine では、単一のリクエストを処理するのと同じ手順を実行し、チャネルを使用して結果をメイン プログラムに送り返します。最後に、単純な for range ループを使用して、すべてのリクエストが完了するのを待ち、結果を出力します。

2. 同時実行量の制御

上記の例では、Goroutine を使用して複数のリクエストを同時に処理しました。ただし、これを行うと、リクエストが多すぎるとシステムがブロックされ、クラッシュする可能性があります。この状況を回避するには、同時実行の量を制御する必要があります。

Go 言語では、sync パッケージの WaitGroup 構造によってこの問題をうまく解決できます。この構造により、コード ブロック内の同時実行量を増やし、すべてのタスクが完了するまで待ってから続行することができます。簡単なサンプル コードを次に示します。

func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()

            resp, err := http.Get(url)
            if err != nil {
                fmt.Println(err)
                return
            }
            defer resp.Body.Close()

            body, err := ioutil.ReadAll(resp.Body)
            if err != nil {
                fmt.Println(err)
                return
            }

            fmt.Printf("url:%s, body:%s", url, body[:20])
        }(url)
    }

    wg.Wait()
}

この例では、最初に WaitGroup 変数を定義します。ループ内では、Add メソッドを使用して同時実行数を増やします。次に、各リクエストを処理するゴルーチンを開始します。最後に、Wait メソッドを使用して、すべてのゴルーチンが完了して実行を再開するのを待ちます。

3. リクエスト結果の同時処理

複数のリクエストを処理する場合、同時実行量を制御するだけでなく、同時実行結果も処理する必要があります。一般に、すべてのリクエストの結果を配列またはその他のデータ構造に収集し、すべてのリクエストが完了した後に処理する必要があります。

Go 言語では、sync パッケージの Mutex 構造体を使用して、複数のゴルーチンによるデータ構造へのアクセスを整理できます。 Mutex を使用すると、複数の goroutine が共有リソースを同時に変更するのを防ぎ、同時に 1 つの goroutine だけが共有リソースにアクセスできるようにすることができます。

以下はサンプル コードです:

type Result struct {
    url string
    body []byte
    err error
}

func fetch(url string, ch chan<- Result) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- Result{url: url, err: err}
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- Result{url: url, err: err}
        return
    }

    ch <- Result{url: url, body: body}
}
func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    var results []Result
    ch := make(chan Result)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        results = append(results, <-ch)
    }

    for _, result := range results {
        if result.err != nil {
            fmt.Println(result.err)
            continue
        }
        fmt.Printf("url:%s, body:%s", result.url, result.body[:20])
    }
}

この例では、各リクエストの戻り値を保存するために Result 構造体を定義します。次に、バッファリングされたチャネルを作成し、ゴルーチンを使用して各リクエストを同時に実行しました。 goroutine では、Mutex を使用して、共有リソースが複数の goroutine によって同時にアクセスされないようにします。最後に、ループを使用してすべてのリクエストが完了するのを待ち、結果を配列に収集します。最後に、結果配列を反復処理し、各リクエストの戻り値を出力します。

概要

Go 言語を使用して同時リクエストを処理すると、システムの効率と信頼性が大幅に向上します。アプリケーションが大量のリクエストを処理する必要がある場合は、ゴルーチンとチャネルを使用してリクエストを同時に実行し、WaitGroup と Mutex を使用して同時実行量を制御し、共有リソースを保護する必要があります。 。このようにして、大量のリクエストを簡単かつ効率的に処理できるようになり、アプリケーションのパフォーマンスと安定性が向上します。

以上がgolang 同時リクエストの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。