Concurrence, goroutines et canaux dans GO: une étude

Cet article explore les fonctionnalités de concurrence de Go, en se concentrant sur les goroutines et les canaux. La concurrence permet de gérer plusieurs tâches apparemment en même temps, mais pas nécessairement simultanément. Goroutines, les threads légers de Go, sont créés à l'aide du mot-clé go, permettant des opérations simultanées. Les canaux facilitent la communication et la synchronisation entre les Goroutines, permettant l'échange de données. L'envoi de données utilise ch <- value, tandis que la réception utilise value := <- ch.

Un exemple de docker-tracle démontre ces concepts:

package main

import (
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "sync"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())

    concurrency, _ := strconv.Atoi(os.Args[1]) // Get concurrency level from command line

    if concurrency <= 0 {
        concurrency = 100 // Default concurrency
    }

    progress := make([]int, concurrency)
    var mu sync.Mutex
    var wg sync.WaitGroup
    wg.Add(concurrency)

    for i := 0; i < concurrency; i++ {
        go func(idx int) {
            defer wg.Done()
            for progress[idx] < 100 {
                mu.Lock()
                if progress[idx] >= 100 {
                    mu.Unlock()
                    break
                }
                inc := rand.Intn(10) + 1
                progress[idx] += inc
                if progress[idx] > 100 {
                    progress[idx] = 100
                }
                mu.Unlock()
                time.Sleep(time.Duration(rand.Intn(400)+100) * time.Millisecond)
            }
        }(i)
    }

    done := make(chan struct{})
    go func() {
        wg.Wait()
        close(done)
    }()

    <-done // Wait for all goroutines to complete

    fmt.Println("Progress:", progress)
}

 Le programme simule les tâches simultanées.  Chaque Goroutine met à jour ses progrès jusqu'à la fin. Un mutex assure la sécurité des threads lors de la mise à jour des valeurs de progression partagées. Un groupe d'attente synchronise l'achèvement de Goroutine. 
   
 apprentissages clés 
 L'exemple met en évidence l'utilisation du mot-clé go pour la création de goroutine et le traitement simultané.  Il montre comment les Goroutines gèrent simultanément les indicateurs de progrès. 
 Exploration supplémentaire 
 Cette exploration soulève des questions sur la fonctionnalité de WaitGroup (incrément / décroissance des compteurs et le blocage avec Wait), les mutexes (prévention des conditions de race) et les conséquences de les omettre.  Le drapeau go test -race pour la détection des conditions de course mérite une enquête plus approfondie. 
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!