duanhan3067 2018-06-27 18:55
浏览 70


I'm doing a nested sync.Map but I wonder if I can save some few lines of code if the value returned by LoadOrStore is the same as the input in case of a map, I mean this:

var mapa sync.Map
mapaInterFace, ok := sessiones.LoadOrStore(userID,mapa)
if ok {
    if !ok{
        return errors.New("type assertion")

If mapa were the same as the returned by LoadOrStore when the value is stored, I can immediately use it, but if not I have to add after the previous code, the type assertion:

    if !ok{
        return errors.New("type assertion")

and doing some often it can make some ugly code

Update: sessiones is type sync.Map

  • 写回答

1条回答 默认 最新

  • duanjuelian4640 2018-06-27 20:09

    As I explain later, you should use pointers for the sync.Map types. Therefore, we can simplify to:

    var mapa, mapb = new(sync.Map), new(sync.Map)
    var key string
    if actual, loaded := mapa.LoadOrStore(key, mapb); loaded {
        if maps, ok := actual.(*sync.Map); ok {
            mapb = maps
        } else {
            // handle loaded value type assertion error

    Now the assignments are cheap because we are assigning pointers (*sync.Map) not structs (sync.Map).

    Package sync

    import "sync" 

    type Map

    Map is like a Go map[interface{}]interface{} but is safe for concurrent use by multiple goroutines without additional locking or coordination. Loads, stores, and deletes run in amortized constant time.

    The Map type is specialized. Most code should use a plain Go map instead, with separate locking or coordination, for better type safety and to make it easier to maintain other invariants along with the map content.

    The Map type is optimized for two common use cases: (1) when the entry for a given key is only ever written once but read many times, as in caches that only grow, or (2) when multiple goroutines read, write, and overwrite entries for disjoint sets of keys. In these two cases, use of a Map may significantly reduce lock contention compared to a Go map paired with a separate Mutex or RWMutex.

    The zero Map is empty and ready for use. A Map must not be copied after first use.

    type Map struct {
            // contains filtered or unexported fields

    func (*Map) LoadOrStore

    func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)

    LoadOrStore returns the existing value for the key if present. Otherwise, it stores and returns the given value. The loaded result is true if the value was loaded, false if stored.

    A sync.Map must not be copied after first use.

    In Go, all arguments and receivers are passed by value, as if by assignment (a copy). For example, go vet reports a sync.Map copy error,

    // go vet: variable declaration copies lock value to arg: sync.Map contains sync.Mutex
    var m sync.Map
    var arg interface{} = m


    var map1, map2 sync.Map
    // go vet: call of map1.LoadOrStore copies lock value: sync.Map contains sync.Mutex
    map1.LoadOrStore("key", map2)

    Use pointers. For example,

        var m sync.Map
        var arg interface{} = &m


        var map1, map2 sync.Map
        map1.LoadOrStore("key", &map2)
    本回答被题主选为最佳回答 , 对您是否有帮助呢?



  • ¥15 【悬赏】canvas 椭圆形内小球边缘与小球碰撞检测
  • ¥50 Delphi5环境下图片文件怎么转换成Base64编码?
  • ¥15 将GPDO_0引|脚设首成PWM1的输出引脚 实验编程该怎么写
  • ¥50 阿里云服务器 CentOS7.9 搭建 openvpn 服务
  • ¥100 开源软件弱点处理规范
  • ¥15 excel如何根据文件名自动搜索并批量导入文件?
  • ¥15 VScode 用户代码片段图标
  • ¥15 streamingtool
  • ¥15 MATLAB图像问题
  • ¥20 树莓派5做人脸情感识别与反馈系统