Linux环境下Go语言的并发编程实践

在Linux环境下使用Go语言进行并发编程，主要依赖于Go的轻量级线程——goroutines和通道（channels）。以下是一些基本的并发编程实践：

1. 使用goroutines

Goroutines是Go语言中实现并发的主要方式。它们比传统的线程更轻量级，启动更快，且可以轻松创建成千上万个。

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Printf("Number: %d\n", i)
        time.Sleep(1 * time.Second)
    }
}

func main() {
    go printNumbers() // 启动一个新的goroutine
    time.Sleep(6 * time.Second) // 等待足够的时间以确保goroutine完成
}

2. 使用通道（channels）

通道是goroutines之间通信的主要方式。它们可以用来传递数据，同步goroutines的执行。

package main

import (
    "fmt"
)

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 将结果发送到通道
    close(c)
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从通道接收结果
    fmt.Println(x, y, x+y)
}

3. 使用sync包

sync包提供了一些工具来帮助管理并发，例如WaitGroup用于等待一组goroutines完成，Mutex用于保护共享资源。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2) // 增加两个等待的goroutines

    go func() {
        defer wg.Done() // 完成时减少计数
        fmt.Println("Goroutine 1")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 2")
    }()

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

4. 使用context包

context包提供了一种在多个goroutines之间传递取消信号、超时和请求范围值的方法。

package main

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

func doSomething(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Cancelled")
            return
        default:
            fmt.Println("Working...")
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    go doSomething(ctx)
    time.Sleep(3 * time.Second) // 等待足够的时间以确保goroutine被取消
}

5. 避免竞态条件

使用go run -race命令来检测竞态条件。确保在访问共享资源时使用互斥锁或其他同步机制。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    counter := 0

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            counter++
            mu.Unlock()
        }()
    }

    wg.Wait()
    fmt.Println(counter)
}

通过这些实践，你可以在Linux环境下有效地使用Go语言进行并发编程。记住，并发编程需要仔细考虑同步和资源共享的问题，以避免竞态条件和其他并发相关的问题。