sync包常用并发安全数据结构

1. sync.WaitGroup 使用
   sync.WaitGroup用于等待一组goroutine完成。Add方法设置计数器，Done方法减少计数器，Wait方法阻塞直到计数器为0。

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    wg.Wait()
    fmt.Println("All workers done")
}

2. sync.Mutex 锁的使用
   sync.Mutex提供了基本的互斥锁功能，Lock加锁，Unlock解锁。它用于保护临界区，确保同时只有一个goroutine可以执行临界区代码。

package main

import (
    "fmt"
    "sync"
)

type Counter struct {
    val int
    mux sync.Mutex
}

func (c *Counter) Increment() {
    c.mux.Lock()
    c.val++
    c.mux.Unlock()
}

func (c *Counter) Value() int {
    return c.val
}

func main() {
    var wg sync.WaitGroup
    counter := Counter{}

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

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

3. sync.Pool 对象复用
   sync.Pool用于存储和复用临时对象，可以减少内存分配和降低GC压力。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var pool sync.Pool

    pool.New = func() interface{} {
        return "New object"
    }

    obj := pool.Get()
    fmt.Println(obj) // New object
    pool.Put(obj)

    obj2 := pool.Get()
    fmt.Println(obj2) // New object, could be the same object as obj
}

4. sync/atomic 原子操作
   sync/atomic包提供了一系列原子操作函数，用于进行无锁的并发安全编程。

package main

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

func main() {
    var wg sync.WaitGroup
    var counter int32

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            atomic.AddInt32(&counter, 1)
        }()
    }

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

在这个示例中，我们使用atomic.AddInt32来确保对counter变量的增加操作是原子的，即使在并发环境下也能保证数据的一致性和完整性。