syncx

Documentation

Index

• type HashMutex
  • func NewHashMutex(keybits int) *HashMutex
  • func (m *HashMutex) Lock(key string) func()
• type KeyMutex
  • func (m *KeyMutex) Lock(key string) func()
  • func (m *KeyMutex) Range(f func(key, value any) bool)

Types

type HashMutex

type HashMutex struct {
	KeyMutex
	// contains filtered or unexported fields
}

HashMutex is a KeyMutex which reduces keys to a fixed number of bits so that there will only ever be a fixed number of mutexes. This means that there's no guarantee that two disctinct keys will use separate locks, but it is guaranteed that different calls with the same key, will use the same lock.

func NewHashMutex

func NewHashMutex(keybits int) *HashMutex

NewHashMutex creates a new hash mutex with keys reduced to the given number of bits, e.g. if bits is 4, then keys be reduced to 16 possible values.

func (*HashMutex) Lock

func (m *HashMutex) Lock(key string) func()

type KeyMutex

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

KeyMutex is a key based mutual exclusion lock. Different keys can hold the lock at the same time, same keys block.

m := KeyMutex{} unlock := m.Lock("key1") defer unlock()

Note that mutexes are not removed from the map when they are unlocked. Therefore the underlying map of mutexes can grow indefinitely.

func (*KeyMutex) Lock

func (m *KeyMutex) Lock(key string) func()

Lock locks on the given key and returns a function to unlock.

func (*KeyMutex) Range

func (m *KeyMutex) Range(f func(key, value any) bool)

Range is the same as sync.Map.Range.