Utilisez Go pour gérer efficacement les demandes simultanées à grande échelle

En utilisant les primitives de concurrence de Go telles que goroutine et canal, vous pouvez gérer efficacement les requêtes simultanées à grande échelle : créez un nombre fixe de goroutines et utilisez des canaux pour mettre en mémoire tampon les requêtes. Protégez les ressources partagées avec des verrous ou des mutex. Limitez le nombre de requêtes simultanées, par exemple en utilisant le contexte pour définir un délai d'attente.

Gérer efficacement les requêtes simultanées à grande échelle avec Go

Introduction
La gestion des requêtes simultanées à grande échelle est un défi courant, en particulier dans les microservices et les applications Web. Go est un langage conçu pour la concurrence et est particulièrement bien adapté pour gérer de telles charges de travail. Cet article présentera les primitives de concurrence et les meilleures pratiques de Go, et utilisera un cas pratique pour démontrer comment gérer efficacement les requêtes simultanées à grande échelle.

Goroutine et Channel
Goroutine est une unité d'exécution parallèle légère dans Go, similaire à un thread. Le canal est un mécanisme de communication entre les goroutines.

Bonne pratique

• Créez un nombre fixe de goroutines au lieu de créer de nouvelles goroutines pour chaque requête.
• Utilisez des canaux pour mettre en mémoire tampon les requêtes et limiter le nombre de requêtes simultanées.
• Utilisez des verrous ou des mutex pour protéger les ressources partagées.

Cas pratique
Nous créons une application web pour traiter les fichiers déposés par les utilisateurs. L'application doit gérer plusieurs demandes de téléchargement de fichiers simultanément.

package main

import (
    "context"
    "log"
    "net/http"
    "sync"
)

const maxConcurrency = 10

var wg sync.WaitGroup

func main() {
    http.HandleFunc("/upload", uploadHandler)
    http.ListenAndServe(":8080", nil)
}

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    wg.Add(1)
    defer wg.Done()

    // 创建一个 goroutine 来处理文件上传
    go func() {
        defer r.Body.Close()
        if err := handleFileUpload(r.Body); err != nil {
            log.Println(err)
        }
    }()
    
    // 限制并发上传的数量
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
    defer cancel()
    select {
    case <-ctx.Done():
        http.Error(w, "Too many concurrent uploads", http.StatusTooManyRequests)
        return
    default:
    }
}

func handleFileUpload(r io.Reader) error {
    // 省略实际的文件上传处理
    return nil
}

Conclusion
En suivant les bonnes pratiques présentées dans cet article, vous pouvez créer des applications Go efficaces et évolutives capables de gérer des requêtes simultanées à grande échelle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!