揭秘golang框架在高并发场景中的最佳实践

package main

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

func main() {
    // 创建一个待处理数据切片
    data := []int{1, 2, 3, 4, 5}
    var wg sync.WaitGroup

    // 为每个数据元素创建一个 goroutine
    for _, num := range data {
        wg.Add(1)
        go func(num int) {
            process(num)
            wg.Done()
        }(num)
    }

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

    fmt.Println("All data processed")
}

func process(num int) {
    // 模拟处理任务
    fmt.Println("Processing data: ", num)
}

package main

import (
    "fmt"
    "sync"
    "atomic"
)

func main() {
    // 使用互斥锁保护共享变量
    var lock sync.Mutex
    var counter int64

    // 创建多个 goroutine 并发递增共享变量
    for i := 0; i < 1000; i++ {
        go func() {
            lock.Lock()
            counter++
            lock.Unlock()
        }()
    }

    // 等待所有 goroutine 完成
    runtime.Gosched()

    // 使用原子递增实现非阻塞递增
    for i := 0; i < 1000; i++ {
        atomic.AddInt64(&counter, 1)
    }

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

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个用于发送和接收数据的频道
    c := make(chan int, 10)
    var wg sync.WaitGroup

    // 创建多个生产者 goroutine 向通道发送数据
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            for j := 0; j < 10; j++ {
                c <- id*10 + j
            }
            wg.Done()
        }(i)
    }

    // 创建多个消费者 goroutine 从通道接收数据
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            for {
                data := <-c
                fmt.Println("Received data: ", data)
            }
            wg.Done()
        }()
    }

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