Linux环境下Go语言并发编程指南

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

1. Goroutines

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

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

func main() {
    go printNumbers() // 创建一个新的goroutine
    time.Sleep(time.Second) // 等待goroutine完成
}

2. Channels

Channels是用于在goroutines之间通信的管道。它们可以用来传递数据，同步goroutines的执行，或者作为信号通知其他goroutines。

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 将结果发送到channel
    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 // 从channel接收值
    fmt.Println(x, y, x+y)
}

3. 同步

Go提供了多种同步机制，包括sync.WaitGroup、sync.Mutex等。

sync.WaitGroup

sync.WaitGroup用于等待一组goroutines完成。

var wg sync.WaitGroup

func worker(id int) {
    defer wg.Done() // 在函数结束时调用Done()
    fmt.Printf("Worker %d starting\n", id)
    // 执行工作...
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    for i := 1; i <= 5; i++ {
        wg.Add(1) // 增加WaitGroup的计数器
        go worker(i)
    }
    wg.Wait() // 等待所有goroutines完成
}

sync.Mutex

sync.Mutex用于保护共享资源，防止多个goroutines同时访问。

var mu sync.Mutex
var sharedResource int

func increment() {
    mu.Lock()         // 加锁
    sharedResource++
    mu.Unlock()       // 解锁
}

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }
    time.Sleep(time.Second)
    fmt.Println(sharedResource)
}

4. Select语句

select语句用于在多个通道操作中进行选择，类似于switch语句，但每个case都是一个通道操作。

func main() {
    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "two"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("Received", msg1)
        case msg2 := <-c2:
            fmt.Println("Received", msg2)
        }
    }
}

5. 并发模式

Go语言中有一些常见的并发模式，如生产者-消费者、工作池等。

生产者-消费者

func producer(c chan<- int) {
    for i := 0; ; i++ {
        c <- i // 发送数据到channel
    }
}

func consumer(c <-chan int, done chan<- bool) {
    for n := range c {
        fmt.Println(n)
    }
    done <- true
}

func main() {
    c := make(chan int)
    done := make(chan bool)

    go producer(c)
    go consumer(c, done)

    <-done // 等待consumer完成
}

工作池

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, j)
        time.Sleep(time.Second)
        fmt.Printf("Worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 9; a++ {
        <-results
    }
}

总结

Go语言的并发编程模型简单而强大，通过goroutines和channels可以轻松实现高效的并发处理。合理使用同步机制和并发模式，可以编写出高性能的并发程序。