Go 语言并发编程大揭秘：掌握 Goroutine、Channel、Select、Mutex 锁、sync、Atomic 的高能技巧

2023-11-05 00:18:39

Go 并发编程：解锁轻量级线程和管道力量

在现代编程世界中，并发性对于处理复杂任务和提高程序效率至关重要。Go 语言凭借其轻量级线程（Goroutine）和强大的并发工具，为开发者提供了掌控多线程编程的利器。

Goroutine：并发编程的轻量级线程

Goroutine 是 Go 语言特有的并发原语，它比传统线程更加轻量级、高效。Goroutine 的创建和调度开销极低，使得开发者可以轻松并发运行数百万个 Goroutine，而不会对系统性能造成显著影响。这种轻量级的特性使 Go 语言在处理密集型计算任务时表现出卓越的并发能力。

代码示例：

package main

import (
    "fmt"
    "runtime"
)

func main() {
    numGoroutines := 1000000
    runtime.GOMAXPROCS(runtime.NumCPU()) // 设置可用的处理器数量

    var wg sync.WaitGroup // 等待组，用于等待所有 Goroutine 执行完毕
    wg.Add(numGoroutines)

    for i := 0; i < numGoroutines; i++ {
        go func(i int) {
            fmt.Println("Goroutine", i, "is running")
            wg.Done() // 完成当前 Goroutine
        }(i)
    }

    wg.Wait() // 等待所有 Goroutine 执行完毕
}

Channel：安全的数据管道

Channel 是 Go 语言中用于在 Goroutine 之间传递数据的管道。它提供了一种安全可靠的数据交换机制，可以防止数据竞争和数据丢失等问题。通过使用 Channel，开发者可以轻松实现 Goroutine 之间的通信和协作，大大简化了并发编程的难度。

代码示例：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup // 等待组，用于等待所有 Goroutine 执行完毕

    ch := make(chan int) // 创建一个 Channel

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            ch <- i // 发送数据到 Channel
            wg.Done() // 完成当前 Goroutine
        }(i)
    }

    for i := 0; i < 10; i++ {
        data := <-ch // 从 Channel 接收数据
        fmt.Println("Received:", data)
    }

    wg.Wait() // 等待所有 Goroutine 执行完毕
}

Select：多路复用，灵活响应

Select 是 Go 语言中用于多路复用的强大工具。它允许开发者同时监听多个 Channel，并在其中任何一个 Channel 有数据可读时进行处理。Select 可以帮助开发者轻松实现非阻塞式的 I/O 操作，提高程序的响应速度和吞吐量。

代码示例：

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup // 等待组，用于等待所有 Goroutine 执行完毕

    ch1 := make(chan int) // 创建 Channel 1
    ch2 := make(chan int) // 创建 Channel 2

    wg.Add(1)
    go func() {
        time.Sleep(1 * time.Second) // 模拟 I/O 操作
        ch1 <- 1 // 发送数据到 Channel 1
        wg.Done() // 完成当前 Goroutine
    }()

    wg.Add(1)
    go func() {
        time.Sleep(2 * time.Second) // 模拟 I/O 操作
        ch2 <- 2 // 发送数据到 Channel 2
        wg.Done() // 完成当前 Goroutine
    }()

    for {
        select {
        case data := <-ch1:
            fmt.Println("Received from Channel 1:", data)
        case data := <-ch2:
            fmt.Println("Received from Channel 2:", data)
        case <-time.After(3 * time.Second): // 设置超时
            fmt.Println("Timeout")
            break
        }
    }

    wg.Wait() // 等待所有 Goroutine 执行完毕
}

Mutex 锁：安全同步访问

Mutex 锁是 Go 语言中用于同步访问共享资源的工具。Mutex 锁可以确保同一时间只有一个 Goroutine 可以访问共享资源，从而防止数据竞争和程序崩溃。Mutex 锁在并发编程中非常重要，它可以帮助开发者构建稳定可靠的多线程程序。

代码示例：

package main

import (
    "fmt"
    "runtime"
    "sync"
)

var (
    mu      sync.Mutex // 互斥锁
    counter int         // 共享资源
)

func main() {
    numGoroutines := 10000
    runtime.GOMAXPROCS(runtime.NumCPU()) // 设置可用的处理器数量

    for i := 0; i < numGoroutines; i++ {
        go func(i int) {
            mu.Lock() // 获取互斥锁
            counter++
            mu.Unlock() // 释放互斥锁
        }(i)
    }

    for counter != numGoroutines {
        // 等待所有 Goroutine 执行完毕
    }

    fmt.Println("Final counter value:", counter)
}