Éviter les conditions de concurrence dans la communication par pipeline de fonctions Golang

Résolvez les conditions de concurrence dans la communication du pipeline de fonctions : utilisez des types sécurisés par concurrence (sync.Mutex) pour synchroniser l'accès aux données du pipeline. Ajoutez une mise en mémoire tampon au pipeline pour stocker temporairement les données et éviter les conflits de données entre les goroutines. Limitez le nombre de goroutines exécutant le pipeline de fonctions simultanément, forçant l'exécution en série.

Éviter les conditions de concurrence dans la communication par pipeline de fonction du langage Go

L'essence de la communication par pipeline simultanée

Dans le langage Go, les pipelines sont un mécanisme utilisé pour la communication entre les goroutines. Ils sont intrinsèquement sécurisés en termes de concurrence, ce qui signifie que plusieurs goroutines peuvent lire et écrire dans le tube en même temps.

Conditions de concurrence

Cependant, lors de l'utilisation de pipelines de fonctions, des conditions de concurrence peuvent survenir. Cela fait référence à un comportement inattendu qui peut se produire lorsque plusieurs goroutines exécutent simultanément un pipeline de fonctions. Plus précisément, cela peut entraîner un ordre de sortie inattendu ou une perte de données.

Éviter les conditions de concurrence

Il existe plusieurs façons de contourner les conditions de concurrence dans les pipelines de fonctions :

Utiliser des types sécurisés pour la concurrence

Utiliser des types sécurisés pour la concurrence (tels que sync.Mutex) pour synchroniser l'accès aux données du pipeline. Cela évite les conditions de concurrence en autorisant une seule goroutine à accéder aux données à la fois.

package main

import (
    "sync"
)

func main() {
    var m sync.Mutex
    numbers := make([]int, 10)

    for i := 0; i < 10; i++ {
        go func(i int) {
            m.Lock()
            defer m.Unlock()

            numbers[i] = i * i
        }(i)
    }

    // 等待所有goroutine完成
}

Utilisation de la mise en mémoire tampon de canal

En ajoutant une mise en mémoire tampon au pipeline, nous pouvons stocker temporairement des données et éviter les conflits de données entre les goroutines.

package main

func main() {
    // 创建一个通道，缓冲为 1
    numbers := make(chan int, 1)

    for i := 0; i < 10; i++ {
        go func(i int) {
            // 写入通道，由于通道缓冲为 1，因此最多会有一个goroutine在写入
            numbers <- i * i
        }(i)
    }

    // 从通道中读取
    for i := 0; i < 10; i++ {
        fmt.Println(<-numbers)
    }
}

Limiter le nombre de goroutines

En limitant le nombre de goroutines pouvant exécuter un pipeline de fonctions en même temps, nous pouvons forcer l'exécution en série et ainsi éviter les conditions de concurrence.

package main

import (
    "context"
    "sync"
)

func main() {
    // 创建带有并发限制 1 的goroutine池
    pool, _ := context.WithCancel(context.Background())
    poolSize := 1

    wg := sync.WaitGroup{}

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            // 限制goroutine池中的并发执行数量
            _ = pool.Err()

            // 访问管道数据
        }
    }
}

En appliquant ces techniques, nous pouvons contourner les conditions de concurrence dans les pipelines de fonctions et garantir la fiabilité et l'exactitude des opérations simultanées.

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!