Go语言（Golang）如何处理高并发？

Go语言通过goroutine和channel提供了高并发的解决方案。

1. 使用goroutine

Goroutine 是 Go 语言中并发的核心。goroutine 是轻量级的线程，它们在一个线程上下文中启动，并由 Go 的运行时管理。创建一个 goroutine 的开销极低。

package main
 
import (
    "fmt"
    "time"
)
 
func hello() {
    fmt.Println("Hello world goroutine")
}
 
func main() {
    go hello() // 创建一个goroutine
 
    fmt.Println("main function")
 
    time.Sleep(1 * time.Second) // 等待goroutine执行完成
}

2. 使用channel

Channel 是 Go 语言中的一个类型，你可以通过它来发送或者接收值，这些值可以在不同的 goroutine 之间同步传递。

package main
 
import (
    "fmt"
    "time"
)
 
func printNumbers(numbers chan int) {
    for number := range numbers {
        fmt.Println(number)
    }
}
 
func main() {
    numbers := make(chan int, 5)
 
    go printNumbers(numbers)
 
    for i := 0; i < 5; i++ {
        numbers <- i
        time.Sleep(time.Second) // 模拟一些处理时间
    }
 
    close(numbers) // 关闭channel，通知printNumbers函数结束循环
}

3. 使用mutex和atomic

在并发编程中，我们还需要处理共享数据的竞争问题。Go 语言提供了 sync 包中的 mutex 和 rwmutex 类型，以及 sync/atomic 包中的原子函数来处理这些问题。

package main
 
import (
    "fmt"
    "sync"
    "sync/atomic"
)
 
var counter int32
var wg sync.WaitGroup
 
func increment() {
    defer wg.Done()
    for i := 0; i < 2; i++ {
        atomic.AddInt32(&counter, 1)
    }
}
 
func main() {
    wg.Add(2)
    go increment()
    go increment()
    wg.Wait()
 
    fmt.Println("Counter:", counter)
}

4. 使用超时和取消

在 Go 语言中，通过 context 包可以实现对 goroutine 的超时管理和取消管理。

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func longRunningOperation(ctx context.Context) {
    select {
    case <-ctx.Done():
        fmt.Println("Operation canceled")
        return
    case <-time.After(5 * time.Second):
        fmt.Println("Operation completed")
    }
}
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()
 
    longRunningOperation(ctx)
}

5. 使用池

使用 sync.Pool 可以提高大量 goroutine 之间共享数据的效率。

package main
 
import (
    "fmt"
    "sync"
)
 
var pool = sync.Pool{
    New: func() interface{} {
        return "Initial value"
    },
}
 
func getValue() interface{} {
    return pool.Get()
}
 
func setValue(value interface{}) {
    pool.Put(value)
}
 
func main() {
    setValue("New value")
    fmt.Println(getValue())
}

6. 使用select处理多个channel