Concurrency, Goroutines, and Channels in Go: A Study

This article explores Go's concurrency features, focusing on goroutines and channels. Concurrency allows handling multiple tasks seemingly at the same time, though not necessarily simultaneously. Goroutines, Go's lightweight threads, are created using the go keyword, enabling concurrent operations. Channels facilitate communication and synchronization between goroutines, enabling data exchange. Sending data uses ch <- value, while receiving uses value := <- ch.

A Docker pull-like example demonstrates these 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)
}

The program simulates concurrent tasks. Each goroutine updates its progress until completion. A mutex ensures thread safety when updating shared progress values. A WaitGroup synchronizes goroutine completion.

Key Learnings

The example highlights the use of the go keyword for goroutine creation and concurrent processing. It demonstrates how goroutines handle multiple progress indicators concurrently.

Further Exploration

This exploration raises questions about WaitGroup's functionality (incrementing/decrementing counters and blocking with Wait), mutexes (preventing race conditions), and the consequences of omitting them. The go test -race flag for detecting race conditions warrants further investigation.

The above is the detailed content of Concurrency, Goroutines, and Channels in Go: A Study. For more information, please follow other related articles on the PHP Chinese website!