Pratique d'optimisation des performances de concurrence en langage Go

La pratique pour optimiser les performances de concurrence du langage Go comprend : l'établissement d'un pool Goroutine pour éviter les frais généraux de création/destruction de goroutines. Optimisez l’utilisation des canaux et évitez de bloquer les opérations pour améliorer la réactivité. Utilisez des verrous en lecture-écriture pour réduire les conflits de verrouillage et améliorer l’efficacité de l’accès aux ressources partagées. Tirez parti du contexte pour propager les informations d’annulation et de date limite au sein des goroutines afin de traiter les demandes d’annulation avec élégance. Améliorez considérablement la vitesse de traitement des requêtes en traitant les requêtes HTTP en parallèle via des goroutines.

Pratique d'optimisation des performances de la concurrence dans le langage Go

La concurrence est un moyen efficace d'améliorer les performances du programme, mais si l'optimisation n'est pas prise en compte, elle peut également entraîner une dégradation des performances. Cet article présente comment appliquer les pratiques d'optimisation de la concurrence dans le langage Go et propose des cas pratiques.

Goroutine Pool

goroutine pool évite les frais généraux liés à la création et à la destruction fréquentes de goroutines. Le débit peut être amélioré en créant un pool de goroutines pré-alloués.

type Job struct {
    task func()
}

func main() {
    pool := make(chan Job, 100)
    for i := 0; i < 100; i++ {
        go func(i int) {
            for {
                job, ok := <-pool
                if !ok {
                    return
                }
                job.task()
            }
        }(i)
    }

    // 向池中提交任务
    for j := 0; j < 100000; j++ {
        pool <- Job{
            task: func() { time.Sleep(500 * time.Microsecond) },
        }
    }

    //关闭池
    close(pool)
}

Optimisation des chaînes

Les chaînes sont un mécanisme important pour la communication entre les goroutines. L'optimisation des canaux peut améliorer l'efficacité du transfert de données.

Évitez d'utiliser des opérations bloquantes : l'utilisation d'opérations non bloquantes (telles que Select 或 Timeout) peut améliorer la réactivité de votre programme.

select {
case value := <-chan:
    // 处理 value
default:
    // 通道为空，执行其他任务
}

Optimisation du verrouillage

Les verrous sont utilisés pour protéger les ressources partagées, mais une utilisation excessive des verrous peut entraîner des blocages ou une dégradation des performances.

Utilisez des verrous en lecture-écriture : les verrous en lecture-écriture permettent à plusieurs opérations de lecture d'accéder simultanément, tandis que les opérations d'écriture ont un accès exclusif aux ressources, ce qui peut réduire les conflits de verrouillage.

import "sync"

var rwmu sync.RWMutex

func main() {
    rwmu.RLock()
    // 并发读操作
    rwmu.RUnlock()

    rwmu.Lock()
    // 写操作
    rwmu.Unlock()
}

Context

Context fournit un moyen de propager les informations d'annulation et de date limite dans les goroutines. Utilisez Context pour gérer les demandes d’annulation avec élégance et éviter de gaspiller des ressources.

import "context"

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    go func() {
        for {
            select {
            case <-ctx.Done():
                return
            default:
                // 执行任务
            }
        }
    }()
}

Cas pratique

Requêtes HTTP parallèles

En utilisant goroutine pour traiter les requêtes HTTP simultanément, la vitesse de traitement des requêtes peut être considérablement améliorée.

import (
    "net/http"
    "time"
)

func main() {
    client := &http.Client{
        Timeout: 10 * time.Second,
    }

    urls := []string{"https://example.com", "https://example2.com", "https://example3.com"}

    var wg sync.WaitGroup
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()
            resp, err := client.Get(url)
            if err != nil {
                // 处理错误
                return
            }
            _ = resp.Body.Close() // 确保关闭连接
        }(url)
    }
    wg.Wait()
}

En appliquant ces pratiques d'optimisation, les performances de concurrence des programmes de langage Go peuvent être considérablement améliorées et le potentiel du programme peut être libéré.

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!