同步映射中键的并发性

在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《同步映射中键的并发性》，聊聊，希望可以帮助到正在努力赚钱的你。

尝试在 golang 中使用同步映射来提供获取特定字符串锁定的能力（例如“lock1”）。

package main

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

var lockMap sync.Map
func main(){

    counter := func(key string,routineId string) {
        _,ok := lockMap.Load(key)
        if(ok){
            fmt.Println(key+ " skipped by "+ routineId)
            return}

        lockMap.Store(key,true)
        defer lockMap.Delete(key)
        for i := 0; i < 10; i++ {
            fmt.Println(key+ " locked by "+ routineId)
        }
    }

    // Starting some goroutines
    go counter("LOCK1","routine1")
    go counter("LOCK1","routine2")
    go counter("LOCK1","routine3")
    go counter("LOCK1","routine4")
    go counter("LOCK1","routine5")
    //adding some sleep so the  routines can execute for sometime
    time.Sleep(time.Second)
}

我知道同步映射在底层使用了 rwmutex。 但是，我想了解同步映射是否允许同时在不同的键上进行多次写入，或者只有一个例程可以一次在整个映射上进行写入？

假设例程1正在设置键“lock1”，例程2是否能够同时设置新值“lock2”，还是必须等待第一次写入完成。

正确答案

对于每把钥匙，您都希望访问现有的锁，或者如果没有锁，则创建一个新锁。使用 sync.Map.LoadOrStore，您可以原子地完成此操作。

// Pre-allocate a new lock, in case it's needed for this key.
newLockIfNeeded = new(sync.Mutex)
lock, _ = lockMap.LoadOrStore(key, newLockIfNeeded)
// Safely acquired the (potentially new) lock for the key
lock.Lock()
defer lock.Unlock()
// do work ...

我会尝试向op提供直接答案

是的，但在特定条件下

sync.map 针对许多读者的独特写入进行了优化。如果有多个例程更新相同的密钥，速度会很慢（请参阅 sync.Map use cases）。它在内部包含一个读映射、一个脏映射和对指针的原子读/写。有些操作使用互斥体，而其他操作则为了速度而绕过它。

是的，只有在以下情况下才允许同时写入/删除：

• 密钥已存在 (m.read.load())
  • atomic.loadpointer 获取快速读取的地图，但调用者仍然可以一起到达下一步
• 上述密钥没有或没有被更新/删除
  • 未更新：sync.map 检查 expunged 指针以查看是否已在其他地方更新
  • 未更新：检查密钥是否已删除时密钥未更改 (compareandswappointer)

是的，如果满足以下任一条件，则允许同时读取

• 该密钥不存在，且未添加新密钥
• 密钥存在且未更新（如上所示）

不，在以下情况下使用互斥锁

• 存储新密钥
  • 示例：批量添加不同的键速度很慢
• 添加新密钥后加载丢失的密钥
  • 示例：频繁删除且检查删除速度慢
• 读取或写入正在更新的密钥
  • 示例：多次更新同一密钥的速度很慢

但是，互斥体不会阻止“是”情况

今天关于《同步映射中键的并发性》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！