golang beemap

beemap 是一个 Go 语言的包，它提供了一个并发安全的 map 实现。根据搜索结果，beemap 通过使用读写锁（sync.RWMutex）来确保在并发环境下对 map 的操作是安全的。这种锁允许多个读操作并发进行，但写操作（添加、删除、更新）会独占锁，以防止其他读写操作同时进行。

以下是 beemap 的一些基本操作：

新建 Map 集合：

func NewBeeMap() *BeeMap {
   return &BeeMap{
       Lock: new(sync.RWMutex),
       BM:   make(map[string]interface{}),
   }
}

这将创建一个新的 BeeMap 实例，其中包含一个读写锁和一个用于存储数据的 map。

通过 key 获取 value：

func (m *BeeMap) Get(k string) interface{} {
   m.Lock.RLock()
   defer m.Lock.RUnlock()
   if val, ok := m.BM[k]; ok {
       return val
   }
   return nil
}

这个函数会尝试获取与给定 key 相关联的 value。如果 key 存在，则返回 value，否则返回 nil。

设置元素：

func (m *BeeMap) Set(k string, v interface{}) bool {
   m.Lock.Lock()
   defer m.Lock.Unlock()
   if val, ok := m.BM[k]; !ok {
       m.BM[k] = v
   } else if val != v {
       m.BM[k] = v
   } else {
       return false
   }
   return true
}

这个函数会设置 map 中的 key-value 对。如果 key 不存在或者新的 value 与旧的不同，则更新 map。如果 key 存在且 value 相同，则返回 false。

覆盖存储元素：

func (m *BeeMap) ReSet(k string, v interface{}) bool {
   m.Delete(k)
   m.Set(k, v)
   return true
}

这个函数会先删除 key，然后设置新的 key-value 对。

检查 key 是否存在：

func (m *BeeMap) Check(k string) bool {
   m.Lock.RLock()
   defer m.Lock.RUnlock()
   if _, ok := m.BM[k]; !ok {
       return false
   }
   return true
}

删除元素：

func (m *BeeMap) Delete(k string) {
   m.Lock.Lock()
   defer m.Lock.Unlock()
   delete(m.BM, k)
}

获取元素个数：

func (m *BeeMap) Size() int {
   m.Lock.RLock()
   defer m.Lock.RUnlock()
   return len(m.BM)
}

获取第一个元素：

func (m *BeeMap) GetFirst() interface{} {
   m.Lock.RLock()
   defer m.Lock.RUnlock()
   for _, v := range m.BM {
       if v != nil {
           return v
       }
   }
   return nil
}

返回第一个元素并从 map 中删除：

func (m *BeeMap) DetachFirst() (string, interface{}) {
   m.Lock.Lock()
   defer m.Lock.Unlock()
   for k, v := range m.BM {
       if v != nil {
           delete(m.BM, k)
           return k, v
       }
   }
   return "", nil
}

这些操作确保了在并发环境下对 map 的安全访问和修改。如果你需要在 Go 程序中使用并发安全的 map，可以考虑使用 beemap 或者类似的库。