vlambda博客
学习文章列表

//用于保存value的interface指针,通过atomic进行原子操作type entry struct { p unsafe.Pointer // *interface{}}

//Map.read 用的就是readOnly，对其进行操作的时候，使用atomic进行保护type readOnly struct { m map[interface{}]*entry // 存储写入的数据 amended bool // 如果Map.dirty有些数据不在中的时候，这个值为true}

//sync.Map的主结构type Map struct { mu Mutex // 锁,操作dirty的时候用的  read atomic.Value // 存的是readOnly结构体，用atomic保护进行操作，无需加锁 dirty map[interface{}]*entry//加锁进行操作，和read构成冗余，misses达到len(dirty)后升级为read  misses int// 未命中read的次数}

//加载方法，也就是提供一个键key,查找对应的值value,如果不存在，通过ok反映func (m *Map) Load(key interface{}) (value interface{}, ok bool) { read, _ := m.read.Load().(readOnly) e, ok := read.m[key] // 不存在，且dirty中有新数据 if !ok && read.amended { m.mu.Lock()//加锁    // 双检查，避免加锁的时候m.dirty提升为m.read,这个时候m.read可能被替换了。 read, _ = m.read.Load().(readOnly) e, ok = read.m[key] if !ok && read.amended { e, ok = m.dirty[key]      // 不管m.dirty中存不存在，都将misses计数加一 // missLocked()中满足条件后就会提升m.dirty m.missLocked()  } m.mu.Unlock() } if !ok { return nil, false } return e.load()// 使用原子操作读取数据} // Map.misses += 1, 如果misses == len(dirty) ,dirty升级为read ，然后dirty指向nilfunc (m *Map) missLocked() { m.misses++ if m.misses < len(m.dirty) { return } m.read.Store(readOnly{m: m.dirty}) m.dirty = nil m.misses = 0}

// 更新或者新增一个entryfunc (m *Map) Store(key, value interface{}) { read, _ := m.read.Load().(readOnly) // 如果m.read存在这个键，并且这个entry没有被标记删除，尝试直接存储。 // 因为m.dirty也指向这个entry,所以m.dirty也保持最新的entry。 if e, ok := read.m[key]; ok && e.tryStore(&value) { return }  // 如果m.read不存在或者已经被标记删除 m.mu.Lock() read, _ = m.read.Load().(readOnly) if e, ok := read.m[key]; ok {//m.read存在并已被标记删除时 if e.unexpungeLocked() {//标记成未被删除 m.dirty[key] = e //m.dirty中不存在这个键，所以加入m.dirty } e.storeLocked(&value)//更新 } else if e, ok := m.dirty[key]; ok {// m.dirty存在这个键时 e.storeLocked(&value)//更新 } else {// key不在read里面，也不在dirty里面时 if !read.amended {// amended 若为false，则表示dirty未被初始化过 m.dirtyLocked()// 初始化dirty，将dirty中未被删除的数据全都复制到dirty中，read中指向nil的数据才会被标记为expunged m.read.Store(readOnly{m: read.m, amended: true})//将amended改为true } m.dirty[key] = newEntry(value)// 将值存入dirty } m.mu.Unlock()} func (m *Map) dirtyLocked() { if m.dirty != nil { return } read, _ := m.read.Load().(readOnly) m.dirty = make(map[interface{}]*entry, len(read.m)) for k, e := range read.m { if !e.tryExpungeLocked() { m.dirty[k] = e } }}func (e *entry) tryExpungeLocked() (isExpunged bool) { p := atomic.LoadPointer(&e.p) for p == nil { // 将已经删除标记为nil的数据标记为expunged if atomic.CompareAndSwapPointer(&e.p, nil, expunged) { return true } p = atomic.LoadPointer(&e.p) } return p == expunged}

//删除一个键值func (m *Map) Delete(key interface{}) { read, _ := m.read.Load().(readOnly) e, ok := read.m[key] if !ok && read.amended {//不在read中，且dirty中有新数据 m.mu.Lock()    //双检查 read, _ = m.read.Load().(readOnly) e, ok = read.m[key] if !ok && read.amended { delete(m.dirty, key)//直接删除dirty的数据 } m.mu.Unlock() } if ok { // read中存在key，将这个key标记为删除状态，但并不删除数据 e.delete() }}

//遍历map(通过回调的方式）func (m *Map) Range(f func(key, value interface{}) bool) { read, _ := m.read.Load().(readOnly) if read.amended {// amended==true，表示dirty中有read没有的数据，此时dirty的数据最全 m.mu.Lock() read, _ = m.read.Load().(readOnly) if read.amended {// 双检查,判断获取锁之前，该值是否变了      // 将dirty升级为read read = readOnly{m: m.dirty} m.read.Store(read) m.dirty = nil m.misses = 0 } m.mu.Unlock() } // 遍历read.m，将值传入回调函数f for k, e := range read.m { v, ok := e.load() if !ok { continue } if !f(k, v) { break } }}