syncx

Documentation

Index

• type LimitPool
  • func NewLimitPool[T any](maxTokens int, factory func() T) *LimitPool[T]
  • func (lp *LimitPool[T]) Get() T
  • func (lp *LimitPool[T]) Put(t T)
• type Map
  • func (m *Map[K, V]) Delete(key K)
  • func (m *Map[K, V]) Load(key K) (value V, ok bool)
  • func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool)
  • func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool)
  • func (m *Map[K, V]) LoadOrStoreFunc(key K, fn func() (V, error)) (actual V, loaded bool, err error)
  • func (m *Map[K, V]) Range(fn func(key K, value V) bool)
  • func (m *Map[K, V]) Store(key K, value V)
• type Pool
  • func NewPool[T any](factory func() T) *Pool[T]
  • func (p *Pool[T]) Get() T
  • func (p *Pool[T]) Put(t T)
• type SegmentKeysLock
  • func NewSegmentKeysLock(size uint32) *SegmentKeysLock
  • func (s *SegmentKeysLock) Lock(key string)
  • func (s *SegmentKeysLock) RLock(key string)
  • func (s *SegmentKeysLock) RUnlock(key string)
  • func (s *SegmentKeysLock) TryLock(key string) bool
  • func (s *SegmentKeysLock) TryRLock(key string) bool
  • func (s *SegmentKeysLock) Unlock(key string)

Examples

• Map.LoadAndDelete
• Map.LoadOrStore

Types

type LimitPool

type LimitPool[T any] struct {
	// contains filtered or unexported fields
}

LimitPool 是对 Pool 的简单封装允许用户通过控制一段时间内对Pool的令牌申请次数来间接控制Pool中对象的内存总占用量

func NewLimitPool

func NewLimitPool[T any](maxTokens int, factory func() T) *LimitPool[T]

func (*LimitPool[T]) Get

func (lp *LimitPool[T]) Get() T

Get 取出一个元素

func (*LimitPool[T]) Put

func (lp *LimitPool[T]) Put(t T)

Put 放回去一个元素

type Map

type Map[K comparable, V any] struct {
	// contains filtered or unexported fields
}

Map 是对 sync.Map 的一个泛型封装 要注意，K 必须是 comparable 的，并且谨慎使用指针作为 K。 使用指针的情况下，两个 key 是否相等，仅仅取决于它们的地址 而不是地址指向的值。可以参考 Load 测试。 注意，key 不存在和 key 存在但是值恰好为零值（如 nil），是两码事

func (*Map[K, V]) Delete

func (m *Map[K, V]) Delete(key K)

Delete 删除键值对

func (*Map[K, V]) Load

func (m *Map[K, V]) Load(key K) (value V, ok bool)

Load 加载键值对

func (*Map[K, V]) LoadAndDelete

func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool)

LoadAndDelete 加载并且删除一个键值对

Example

var m = Map[string, *User]{}
_, loaded := m.LoadAndDelete("Tom")
fmt.Println(loaded)
m.Store("Tom", nil)
val, loaded := m.LoadAndDelete("Tom")
if loaded {
	fmt.Printf("key=Tom, val=%v 被删除\n", val)
}
m.Store("Tom", &User{Name: "Tom"})
val, loaded = m.LoadAndDelete("Tom")
if loaded {
	fmt.Printf("key=Tom, val=%v 被删除\n", val)
}

Output:

false
key=Tom, val=<nil> 被删除
key=Tom, val=&{Tom} 被删除

func (*Map[K, V]) LoadOrStore

func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool)

LoadOrStore 加载或者存储一个键值对 true 代表是加载的，false 代表执行了 store

Example

var m = Map[string, *User]{}
_, loaded := m.LoadOrStore("Tom", &User{Name: "Tom"})
// 执行存储
if !loaded {
	fmt.Println("设置了新值 Tom")
}

_, loaded = m.LoadOrStore("Tom", &User{Name: "Tom-copy"})
// Tom 这个 key 已经存在，执行加载
if loaded {
	fmt.Println("加载旧值 Tom")
}

_, loaded = m.LoadOrStore("Jerry", nil)
// 执行存储，注意值是 nil
if !loaded {
	fmt.Println("设置了新值 nil")
}
val, loaded := m.LoadOrStore("Jerry", &User{Name: "Jerry"})
// Jerry 这个 key 已经存在，执行加载，于是把原本的 nil 加载出来
if loaded {
	fmt.Printf("加载旧值 %v", val)
}

Output:

设置了新值 Tom
加载旧值 Tom
设置了新值 nil
加载旧值 <nil>

func (*Map[K, V]) LoadOrStoreFunc

func (m *Map[K, V]) LoadOrStoreFunc(key K, fn func() (V, error)) (actual V, loaded bool, err error)

LoadOrStoreFunc 是一个优化，也就是使用该方法能够避免无意义的创建实例。 如果你的初始化过程非常消耗资源，那么使用这个方法是有价值的。 它的代价就是 Key 不存在的时候会多一次 Load 调用。 当 fn 返回 error 的时候，LoadOrStoreFunc 也会返回 error。

func (*Map[K, V]) Range

func (m *Map[K, V]) Range(fn func(key K, value V) bool)

Range 遍历, fn 不能为 nil 传入 fn 的时候，K 和 V 直接使用对应的类型，如果 fn 返回 false，那么就会中断遍历

func (*Map[K, V]) Store

func (m *Map[K, V]) Store(key K, value V)

Store 存储键值对

type Pool

type Pool[T any] struct {
	// contains filtered or unexported fields
}

func NewPool

func NewPool[T any](factory func() T) *Pool[T]

func (*Pool[T]) Get

func (p *Pool[T]) Get() T

func (*Pool[T]) Put

func (p *Pool[T]) Put(t T)

type SegmentKeysLock

type SegmentKeysLock struct {
	// contains filtered or unexported fields
}

SegmentKeysLock 部分key lock结构定义

func NewSegmentKeysLock

func NewSegmentKeysLock(size uint32) *SegmentKeysLock

NewSegmentKeysLock 创建 SegmentKeysLock 示例

func (*SegmentKeysLock) Lock

func (s *SegmentKeysLock) Lock(key string)

Lock 写锁加锁

func (*SegmentKeysLock) RLock

func (s *SegmentKeysLock) RLock(key string)

RLock 读锁加锁

func (*SegmentKeysLock) RUnlock

func (s *SegmentKeysLock) RUnlock(key string)

RUnlock 读锁解锁

func (*SegmentKeysLock) TryLock

func (s *SegmentKeysLock) TryLock(key string) bool

TryLock 试着加锁，加锁成功会返回 true

func (*SegmentKeysLock) TryRLock

func (s *SegmentKeysLock) TryRLock(key string) bool

TryRLock 试着加读锁，加锁成功会返回 true

func (*SegmentKeysLock) Unlock

func (s *SegmentKeysLock) Unlock(key string)

Unlock 写锁解锁