Go标准库sync功能实例详解

package main
import (
    "fmt"
    "sync"
    "time"
)
var (
    count int           // 共享资源
    mutex sync.Mutex    // 互斥锁保护count
)
// 对共享资源执行加1操作
func increment() {
    mutex.Lock()         // 加锁，排他访问
    defer mutex.Unlock() // 延迟释放锁，确保函数退出时必释放
    count++
    fmt.Printf("goroutine %d: count = %d\n", time.Now().UnixNano()%1000, count)
    time.Sleep(100 * time.Millisecond) // 模拟业务耗时
}
func main() {
    var wg sync.WaitGroup // 用于等待所有goroutine完成
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }
    wg.Wait() // 等待所有goroutine执行完毕
    fmt.Printf("最终count值：%d\n", count)
}

package main
import (
    "fmt"
    "sync"
    "time"
)
var (
    data   = make(map[string]string) // 共享字典
    rwLock sync.RWMutex              // 读写锁保护data
)
// 读操作：获取数据，加读锁
func readData(key string) string {
    rwLock.RLock()
    defer rwLock.RUnlock()
    time.Sleep(50 * time.Millisecond) // 模拟读耗时
    return data[key]
}
// 写操作：更新数据，加写锁
func writeData(key, value string) {
    rwLock.Lock()
    defer rwLock.Unlock()
    time.Sleep(100 * time.Millisecond) // 模拟写耗时
    data[key] = value
    fmt.Printf("更新数据：%s=%s\n", key, value)
}
func main() {
    var wg sync.WaitGroup
    // 先初始化数据
    writeData("name", "Go")
    // 启动10个读goroutine
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            val := readData("name")
            fmt.Printf("读goroutine %d: 读取到 %s\n", idx, val)
        }(i)
    }
    // 启动2个写goroutine
    for i := 0; i < 2; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            writeData("name", fmt.Sprintf("Go-%d", idx))
        }(i)
    }
    wg.Wait()
    fmt.Println("最终数据：", data["name"])
}

package main
import (
    "fmt"
    "sync"
    "time"
)
// 模拟任务处理
func processTask(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 任务完成后计数器减1
    fmt.Printf("任务 %d 开始执行\n", id)
    time.Sleep(time.Duration(id*100) * time.Millisecond) // 模拟任务耗时
    fmt.Printf("任务 %d 执行完成\n", id)
}
func main() {
    var wg sync.WaitGroup
    taskCount := 5
    // 新增5个任务，计数器设为5
    wg.Add(taskCount)
    for i := 0; i < taskCount; i++ {
        go processTask(i, &wg) // 传递WaitGroup指针，避免值拷贝
    }
    fmt.Println("等待所有任务完成...")
    wg.Wait() // 阻塞直至所有任务完成
    fmt.Println("所有任务均已完成，程序退出")
}

package main
import (
    "fmt"
    "sync"
    "time"
)
var (
    queue  []int         // 消息队列
    mutex  sync.Mutex    // 保护队列
    cond   = sync.NewCond(&mutex) // 绑定互斥锁的条件变量
    maxLen = 5           // 队列最大长度
)
// 生产者：向队列添加数据
func producer(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < 3; i++ {
        mutex.Lock()
        // 队列满时，等待消费者消费（条件不满足）
        for len(queue) >= maxLen {
            cond.Wait() // 释放锁，阻塞等待通知
        }
        // 生产数据
        data := id*10 + i
        queue = append(queue, data)
        fmt.Printf("生产者 %d: 生产数据 %d，队列长度：%d\n", id, data, len(queue))
        mutex.Unlock()
        cond.Signal() // 唤醒一个消费者
        time.Sleep(300 * time.Millisecond)
    }
}
// 消费者：从队列获取数据
func consumer(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < 2; i++ {
        mutex.Lock()
        // 队列空时，等待生产者生产（条件不满足）
        for len(queue) == 0 {
            cond.Wait() // 释放锁，阻塞等待通知
        }
        // 消费数据
        data := queue[0]
        queue = queue[1:]
        fmt.Printf("消费者 %d: 消费数据 %d，队列长度：%d\n", id, data, len(queue))
        mutex.Unlock()
        cond.Signal() // 唤醒一个生产者
        time.Sleep(500 * time.Millisecond)
    }
}
func main() {
    var wg sync.WaitGroup
    // 启动2个生产者，3个消费者
    wg.Add(2 + 3)
    for i := 0; i < 2; i++ {
        go producer(i, &wg)
    }
    for i := 0; i < 3; i++ {
        go consumer(i, &wg)
    }
    wg.Wait()
    fmt.Println("生产消费完成，队列剩余数据：", queue)
}

package main
import (
    "fmt"
    "sync"
    "time"
)
type Config struct {
    Host string
    Port int
}
var (
    config *Config
    once   sync.Once
)
// 加载配置，确保只执行一次
func loadConfig() *Config {
    fmt.Println("开始加载配置（仅执行一次）")
    // 模拟配置加载耗时（如读取文件、远程请求）
    time.Sleep(1 * time.Second)
    return &Config{
        Host: "localhost",
        Port: 8080,
    }
}
// 获取配置单例
func GetConfig() *Config {
    once.Do(func() {
        config = loadConfig()
    })
    return config
}
func main() {
    var wg sync.WaitGroup
    // 10个goroutine同时获取配置
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            cfg := GetConfig()
            fmt.Printf("goroutine %d: 获取配置 %+v\n", idx, cfg)
        }(i)
    }
    wg.Wait()
}

package main
import (
    "bytes"
    "fmt"
    "sync"
    "time"
)
// 创建字节缓冲区对象池
var bufPool = sync.Pool{
    New: func() interface{} {
        fmt.Println("创建新的缓冲区（无复用对象时）")
        return &bytes.Buffer{}
    },
}
// 处理数据：复用缓冲区
func processData(data string) {
    // 从池中获取缓冲区
    buf := bufPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()       // 清空缓冲区，确保下次复用干净
        bufPool.Put(buf)  // 归还缓冲区到池
    }()
    // 模拟数据处理
    buf.WriteString("处理数据：")
    buf.WriteString(data)
    fmt.Println(buf.String())
    time.Sleep(100 * time.Millisecond)
}
func main() {
    var wg sync.WaitGroup
    // 20个goroutine复用缓冲区
    for i := 0; i < 20; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            processData(fmt.Sprintf("message-%d", idx))
        }(i)
    }
    wg.Wait()
}

package main
import (
    "fmt"
    "sync"
    "time"
)
func main() {
    var m sync.Map
    var wg sync.WaitGroup
    // 启动5个写goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            key := fmt.Sprintf("key-%d", idx)
            value := idx * 10
            m.Store(key, value)
            fmt.Printf("写goroutine %d: 存储 %s=%d\n", idx, key, value)
            time.Sleep(50 * time.Millisecond)
        }(i)
    }
    wg.Wait()
    // 遍历字典
    fmt.Println("\n遍历字典：")
    m.Range(func(key, value interface{}) bool {
        fmt.Printf("%v=%v\n", key, value)
        return true // 继续遍历
    })
    // 读取指定键
    key := "key-2"
    val, ok := m.Load(key)
    if ok {
        fmt.Printf("\n读取 %s: %v\n", key, val)
    }
    // 删除指定键
    m.Delete(key)
    val, ok = m.Load(key)
    fmt.Printf("删除 %s 后，是否存在：%v，值：%v\n", key, ok, val)
}

package main
import (
    "fmt"
    "sync"
    "time"
)
// 任务函数：生成结果
func task(id int) int {
    time.Sleep(time.Duration(id*200) * time.Millisecond)
    return id * 10 // 模拟任务结果
}
func main() {
    var wg sync.WaitGroup
    var mutex sync.Mutex
    taskCount := 6
    results := make([]int, 0, taskCount) // 存储任务结果
    // 并发执行任务
    wg.Add(taskCount)
    for i := 0; i < taskCount; i++ {
        go func(idx int) {
            defer wg.Done()
            res := task(idx)
            // 安全写入结果（加锁保护切片）
            mutex.Lock()
            results = append(results, res)
            mutex.Unlock()
            fmt.Printf("任务 %d 完成，结果：%d\n", idx, res)
        }(i)
    }
    wg.Wait()
    fmt.Println("所有任务完成，结果汇总：", results)
}