Technologie d'optimisation de la concurrence de la fonction Golang

Les techniques d'optimisation de la simultanéité dans les fonctions Go incluent : 1. Pool Goroutine : pré-allouer et gérer un groupe de Goroutines pour réduire les frais de création et de destruction 2. Capacité du canal : limiter le nombre de Goroutines pouvant entrer dans le canal en même temps ; pour éviter une concurrence excessive ; 3. Traitement des interruptions : libérez les ressources système bloquées en temps opportun, par exemple en supprimant Goroutine en attente d'IO du planificateur.

Technologie d'optimisation de la concurrence de la fonction Go

Dans les scénarios d'applications à haute concurrence, l'optimisation des performances de concurrence des fonctions est cruciale. Le langage Go offre de puissantes fonctionnalités de concurrence. Cet article présentera plusieurs techniques d'optimisation couramment utilisées et démontrera leurs applications avec des cas pratiques.

1. Goroutine Pool

Goroutine Pool est un mécanisme qui pré-attribue et gère un groupe de Goroutines. En réutilisant les Goroutines, les frais généraux causés par la création et la destruction des Goroutines peuvent être réduits.

package main

import (
    "sync"
    "fmt"
)

func main() {
    // 创建一个拥有 10 个 Goroutine 的 Goroutine 池
    var wg sync.WaitGroup
    pool := make(chan chan int, 10)
    for i := 0; i < 10; i++ {
        pool <- make(chan int)
    }

    for i := 0; i < 100; i++ {
        wg.Add(1)
        work := <-pool
        go func(id int, work chan int) {
            fmt.Printf("Worker %d completed task %d\n", id, id)
            work <- id
            wg.Done()
        }(i, work)
    }

    // 等待所有 Goroutine 完成工作
    wg.Wait()
    close(pool)
}

2. Capacité du canal

L'utilisation d'un canal avec capacité peut limiter le nombre de Goroutines pouvant entrer dans le canal en même temps. Cela empêche les goroutines de se faire trop concurrence, améliorant ainsi la concurrence.

package main

import (
    "sync"
    "fmt"
)

func main() {
    // 创建一个容量为 10 的通道
    ch := make(chan int, 10)
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            ch <- id
            wg.Done()
        }(i)
    }

    for i := 0; i < 100; i++ {
        fmt.Printf("Received %d\n", <-ch)
    }
    wg.Wait()
}

3. Gestion des interruptions

En gérant les interruptions Goroutine, les ressources système bloquées peuvent être libérées à temps. Par exemple, lorsqu'un Goroutine est bloqué en attente d'opérations d'E/S, il peut être supprimé du planificateur système via la gestion des interruptions.

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 创建一个具有 5 秒超时的上下文
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // 在 Goroutine 中进行阻塞操作
    go func() {
        for {
            select {
            case <-ctx.Done():
                return
            default:
                time.Sleep(1 * time.Second)
                fmt.Println("Sleeping...")
            }
        }
    }()

    time.Sleep(10 * time.Second)
}

Grâce aux techniques ci-dessus, les performances de concurrence des fonctions Go peuvent être efficacement optimisées. Dans le développement réel, il est nécessaire de sélectionner une solution d'optimisation appropriée basée sur des scénarios d'application spécifiques pour obtenir la meilleure efficacité de concurrence.

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!