Introduction à la syntaxe et aux fonctions intégrées du contrôle de concurrence des fonctions Golang

Le langage Go contrôle la simultanéité des fonctions grâce à une syntaxe intégrée, notamment : go func() crée Goroutine, sync.Mutex mutex protège les données partagées, sync.WaitGroup coordonne l'exécution de Goroutine et le contrôle coopératif des variables de condition sync.Cond. Ces syntaxes intégrées prennent en charge l'exécution simultanée, la protection des données et le contrôle collaboratif, optimisant ainsi les performances du programme. Le cas du calcul parallèle de la séquence de Fibonacci démontre son application pratique.

Introduction à la syntaxe et aux fonctions intégrées du contrôle de concurrence des fonctions du langage Go

La concurrence dans le langage Go est implémentée via Goroutine, qui est un fil léger dans le langage Go. En utilisant Goroutine, nous pouvons écrire des programmes simultanés pour tirer pleinement parti des processeurs multicœurs et améliorer les performances des programmes.

Syntaxe intégrée

Le langage Go fournit la syntaxe intégrée suivante pour contrôler la simultanéité des fonctions :

• go func() : Créez un nouveau Goroutine qui exécutera la fonction func simultanément.
• sync.Mutex : Verrou Mutex, utilisé pour protéger les données partagées.
• sync.WaitGroup : Groupe d'attente, utilisé pour attendre qu'un groupe de Goroutines se termine.
• sync.Cond : Variable de condition, utilisée pour coordonner la collaboration entre les Goroutines.

Fonctionnalités

Ces syntaxes intégrées offrent les fonctionnalités suivantes :

• Exécution simultanée : plusieurs Goroutines peuvent être exécutées en parallèle, utilisant ainsi pleinement les ressources du processeur multicœur.
• Protection des données : les verrous Mutex peuvent garantir que les données partagées ne sont accessibles que par un seul Goroutine à la fois, empêchant ainsi la corruption des données.
• Contrôle de la collaboration : les groupes d'attente et les variables de condition peuvent contrôler la collaboration entre les Goroutines pour garantir qu'ils s'exécutent dans le bon ordre.

Cas pratique

Ce qui suit est un cas pratique de calcul de la séquence de Fibonacci, démontrant comment utiliser Goroutine pour des calculs simultanés :

package main

import (
    "fmt"
    "sync"
)

// 计算斐波那契数列
func fibonacci(n int) int {
    if n <= 1 {
        return n
    }
    return fibonacci(n-1) + fibonacci(n-2)
}

func main() {
    // 创建互斥锁保护计数器
    var mu sync.Mutex
    // 创建等待组等待所有 Goroutine 完成
    var wg sync.WaitGroup

    // 并发计算斐波那契数列
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            result := fibonacci(i)

            // 使用互斥锁保护计数器
            mu.Lock()
            fmt.Printf("Fibonacci(%d) = %d\n", i, result)
            mu.Unlock()
        }(i)
    }

    // 等待所有 Goroutine 完成
    wg.Wait()
}

Ce programme calculera les 10 premiers nombres de la séquence de Fibonacci en parallèle, et utilisera un mutex pour protéger la sortie et garantir que chaque numéro est imprimé dans l'ordre.

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!