golang 之 sync包

合集 - golang(10)

1.go 定义类型2023-09-252.Golang goroutine、sync.WaitGroup、Channel实现并发详解2023-10-15

3.golang 之 sync包2023-10-16

4.golang 之socket-tcp2023-10-215.golang 之UDP2023-10-216.golang 之命令行参数2023-10-227.golang之 pprof性能调优2023-10-228.golang 循环-判断2023-10-309.golang context 操作2023-11-0410.etcd 事务操作2023-12-28

收起

sync.Map

1. 并发操作一个map的时候内置的map不是并发安全的，需要初始化map才能使用
2. sync.Map 是一个开箱即用的并发安全的不用初始化参数，定义一下参数，直接引用参数
3. 使用方法：
   1. Store： 设置参数
   2. Load： 通过key获取值
   3. LoadOrStore：
   4. Delete：删除
   5. Rang：循环

var syncMap sync.Map

syncMap.Store(key,value)
syncMap.Load(key)
syncMap.LoadOrStore()
syncMap.Delete()
syncMap.Range()

 

sync.WaitGroup

1. 是一个结构体，是值类型，给结构体传参数的时候要传指针类型
2. 　　使用开启goroutine时，main 的方法需要优雅的等待goroutine 都执行完成之后在关闭main的goroutine。  
3. 　　使用方法：
   1. Add： 添加计数器
   2. Done： 删除计数器
   3. Wait： 等待计数器为0 

 

package main

import (
    "fmt"
    "strconv"
    "sync"
)

/*
使用goroutine map 存值时候一定要使用sync.Map{}方式
内置的map 在goroutine时超过20个会报错，超过最大map限制
*/
var m2 = sync.Map{}
// 开启 sync.WaitGroup
var wg sync.WaitGroup

func goroutine_demo(){
    for i := 0; i< 10000;i++{
        
        wg.Add(1)
        go func(n int){
            key := strconv.Itoa(n)
            //必须使用sync.Map{}内置的Store方法设置键值对
            m2.Store(key,n)
            // 必须使用sync.Map{}提供的Load 方法根据key取值
            value,_ := m2.Load(key)   
            fmt.Printf("k=: %v, v=:%v\n",key,value)
            wg.Done()
        }(i)
    }
}
func main(){
    goroutine_demo()

}

 

sync.Mutex

1. 锁，多个goroutine 同一时间操作公共资源时需要加锁，保证数据完整性
2. 操作方法：

1. 1. Lock： 互斥锁
   2. Unlock： 解互斥锁

package main

import (
    "fmt"
    "sync"
)

// globa ... x
var x = 0
var wg sync.WaitGroup

// 锁声明
var lock sync.Mutex
// add 
func add(){
    defer wg.Done()
    for i :=0 ; i < 1000; i++ {
        //加锁
        lock.Lock()
        x = x + 1
        // 释放锁
        lock.Unlock()
    }
}

func main(){
    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)

}

sync.RWMutex

1. 特点　

   1. 读的goroutine 时获取的是读锁后续的goroutine能读不能写

   2. 写的goroutine时获取的写锁，后续的goroutine不管读还是写都要等待获取锁

2. 操作方法：

1. 1. RLock：锁
   2. RUnlock： 解锁

package main

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

var (
    x  =  0
    wg sync.WaitGroup
    lock  sync.Mutex
    rwlock  sync.RWMutex
)

func read(){
    defer wg.Done()
    rwlock.RLock()
    // lock.Lock()
    fmt.Println(x)
    time.Sleep(time.Millisecond)
    rwlock.RUnlock()
    // lock.Unlock()
}

func write(){
    defer wg.Done()
    // lock.Lock()
    rwlock.RLock()
    x = x +1
    time.Sleep(time.Millisecond * 5)
    // lock.Unlock()
    rwlock.RUnlock()
}

func main(){
    start := time.Now()
    for i :=0 ; i < 10; i++{
        go write()
        wg.Add(1)
    }
    // time.Sleep(time.Second)
    for i :=0; i< 1000; i++{
        go read()
        wg.Add(1)
    }
    wg.Wait()
    fmt.Println(time.Now().Sub(start))
}

 sync.Once

某些函数只能执行一次的时候，就可以使用sync.Once

var once sync.Once

func f2(ch1 <-chan int ,ch2 chan<- int){
    defer wg.Done()
    for {
        x,ok := <- ch1
        if !ok {
            break
        }
        ch2 <- x * x
    }
    // 确保某个操作只执行一次
    once.Do(func() { close(ch2) })
}