syncs
package
This package is not in the latest version of its module.
Details
Validgo.mod file
The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
- Redistributable license
Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
- Tagged version
Modules with tagged versions give importers more predictable builds.
- Stable version
When a project reaches major version v1 it is considered stable.
- Learn more about best practices
Repository
Links
Open Source Insights
Documentation¶
Overview¶
Package syncs contains additional sync types and functionality.
Index¶
- func AssertLocked(m *Mutex)
- func AssertRLocked(rw *RWMutex)
- func AssertWLocked(rw *sync.RWMutex)
- func ClosedChan() <-chan struct{}
- type AtomicValue
- type Map
- func (m *Map[K, V]) All() iter.Seq2[K, V]
- func (m *Map[K, V]) Clear()
- func (m *Map[K, V]) Delete(key K)
- func (m *Map[K, V]) Keys() iter.Seq[K]
- func (m *Map[K, V]) Len() int
- func (m *Map[K, V]) Load(key K) (value V, loaded bool)
- func (m *Map[K, V]) LoadAndDelete(key K) (value V, loaded bool)
- func (m *Map[K, V]) LoadFunc(key K, f func(value V, loaded bool))
- func (m *Map[K, V]) LoadOrInit(key K, f func() V) (actual V, loaded bool)
- func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool)
- func (m *Map[K, V]) Store(key K, value V)
- func (m *Map[K, V]) Swap(key K, value V) (oldValue V)
- func (m *Map[K, V]) Values() iter.Seq[V]
- func (m *Map[K, V]) WithLock(f func(m2 map[K]V))
- type Mutex
- type MutexValue
- type Pool
- type RWMutex
- type Semaphore
- type ShardValue
- type ShardedInt
- type ShardedMap
- func (m *ShardedMap[K, V]) Contains(key K) bool
- func (m *ShardedMap[K, V]) Delete(key K) (shrunk bool)
- func (m *ShardedMap[K, V]) Get(key K) (value V)
- func (m *ShardedMap[K, V]) GetOk(key K) (value V, ok bool)
- func (m *ShardedMap[K, V]) Len() int
- func (m *ShardedMap[K, V]) Mutate(key K, mutator func(oldValue V, oldValueExisted bool) (newValue V, keep bool)) (sizeDelta int)
- func (m *ShardedMap[K, V]) Set(key K, value V) (grew bool)
- type WaitGroupChan
Constants¶
This section is empty.
Variables¶
This section is empty.
Functions¶
funcAssertRLocked¶added inv1.14.0
func AssertRLocked(rw *RWMutex)
AssertRLocked panics if rw is not locked for reading or writing.
funcAssertWLocked¶added inv1.14.0
AssertWLocked panics if rw is not locked for writing.
Types¶
typeAtomicValue¶added inv1.30.0
type AtomicValue[Tany] struct {// contains filtered or unexported fields}
AtomicValue is the generic version ofatomic.Value.SeeMutexValue for guidance on whether to use this type.
func (*AtomicValue[T])CompareAndSwap¶added inv1.30.0
func (v *AtomicValue[T]) CompareAndSwap(oldV, newV T) (swappedbool)
CompareAndSwap executes the compare-and-swap operation for the Value.It panics if T is not comparable.
func (*AtomicValue[T])Load¶added inv1.30.0
func (v *AtomicValue[T]) Load() T
Load returns the value set by the most recent Store.It returns the zero value for T if the value is empty.
func (*AtomicValue[T])LoadOk¶added inv1.30.0
func (v *AtomicValue[T]) LoadOk() (_ T, okbool)
LoadOk is like Load but returns a boolean indicating whether the value wasloaded.
func (*AtomicValue[T])Store¶added inv1.30.0
func (v *AtomicValue[T]) Store(x T)
Store sets the value of the Value to x.
func (*AtomicValue[T])Swap¶added inv1.30.0
func (v *AtomicValue[T]) Swap(x T) (old T)
Swap stores new into Value and returns the previous value.It returns the zero value for T if the value is empty.
typeMap¶added inv1.34.0
type Map[Kcomparable, Vany] struct {// contains filtered or unexported fields}
Map is a Go map protected by async.RWMutex.It is preferred oversync.Map for maps with entries that changeat a relatively high frequency.This must not be shallow copied.
func (*Map[K, V])All¶added inv1.76.0
All iterates over all entries in the map in an undefined order.A read lock is held for the entire duration of the iteration.Use the [WithLock] method instead to mutate the map during iteration.
func (*Map[K, V])Clear¶added inv1.50.0
func (m *Map[K, V]) Clear()
Clear removes all entries from the map.
func (*Map[K, V])Delete¶added inv1.34.0
func (m *Map[K, V]) Delete(key K)
Delete deletes the entry identified by key.
func (*Map[K, V])Keys¶added inv1.76.0
Keys iterates over all keys in the map in an undefined order.A read lock is held for the entire duration of the iteration.Use the [WithLock] method instead to mutate the map during iteration.
func (*Map[K, V])Load¶added inv1.34.0
Load loads the value for the provided key and whether it was found.
func (*Map[K, V])LoadAndDelete¶added inv1.34.0
LoadAndDelete returns the value for the given key if it exists.It ensures that the map is cleared of any entry for the key.
func (*Map[K, V])LoadFunc¶added inv1.52.0
LoadFunc calls f with the value for the provided keyregardless of whether the entry exists or not.The lock is held for the duration of the call to f.
func (*Map[K, V])LoadOrInit¶added inv1.52.0
LoadOrInit returns the value for the given key if it existsotherwise f is called to construct the value to be set.The lock is held for the duration to prevent duplicate initialization.
func (*Map[K, V])LoadOrStore¶added inv1.34.0
LoadOrStore returns the value for the given key if it existsotherwise it stores value.
func (*Map[K, V])Store¶added inv1.34.0
func (m *Map[K, V]) Store(key K, value V)
Store stores the value for the provided key.
func (*Map[K, V])Swap¶added inv1.64.0
func (m *Map[K, V]) Swap(key K, value V) (oldValue V)
Swap stores the value for the provided key, and returns the previous value(if any). If there was no previous value set, a zero value will be returned.
typeMutex¶added inv1.92.0
Mutex is an alias for sync.Mutex.
It's only not a sync.Mutex when built with the ts_mutex_debug build tag.
typeMutexValue¶added inv1.80.0
type MutexValue[Tany] struct {// contains filtered or unexported fields}
MutexValue is a value protected by a mutex.
AtomicValue,MutexValue,atomic.Pointer are similar andoverlap in their use cases.
Useatomic.Pointer if the value being stored is a pointer andyou only ever need load and store operations.An atomic pointer only occupies 1 word of memory.
UseMutexValue if the value being stored is not a pointer oryou need the ability for a mutex to protect a set of operationsperformed on the value.A mutex-guarded value occupies 1 word of memory plusthe memory representation of T.
AtomicValue is useful for non-pointer types that happen tohave the memory layout of a single pointer.Examples include a map, channel, func, or a single field structthat contains any prior types.An atomic value occupies 2 words of memory.Consequently, Storing of non-pointer types always allocates.
Note thatAtomicValue has the ability to report whether it was setwhileMutexValue lacks the ability to detect if the value was setand it happens to be the zero value of T. If such a use case isnecessary, then you could consider wrapping T in [opt.Value].
func (*MutexValue[T])Load¶added inv1.80.0
func (m *MutexValue[T]) Load() T
Load returns a shallow copy of the underlying value.
func (*MutexValue[T])Store¶added inv1.80.0
func (m *MutexValue[T]) Store(v T)
Store stores a shallow copy of the provided value.
func (*MutexValue[T])Swap¶added inv1.80.0
func (m *MutexValue[T]) Swap(new T) (old T)
Swap stores new into m and returns the previous value.
func (*MutexValue[T])WithLock¶added inv1.80.0
func (m *MutexValue[T]) WithLock(f func(p *T))
WithLock calls f with a pointer to the value while holding the lock.The provided pointer must not leak beyond the scope of the call.
typePool¶added inv1.70.0
type Pool[Tany] struct {// New optionally specifies a function to generate// a value when Get would otherwise return the zero value of T.// It may not be changed concurrently with calls to Get.New func() T// contains filtered or unexported fields}
Pool is the generic version ofsync.Pool.
func (*Pool[T])Get¶added inv1.70.0
func (p *Pool[T]) Get() T
Get selects an arbitrary item from the Pool, removes it from the Pool,and returns it to the caller. Seesync.Pool.Get.
typeRWMutex¶added inv1.92.0
RWMutex is an alias for sync.RWMutex.
It's only not a sync.RWMutex when built with the ts_mutex_debug build tag.
typeSemaphore¶added inv1.8.0
type Semaphore struct {// contains filtered or unexported fields}Semaphore is a counting semaphore.
Use NewSemaphore to create one.
funcNewSemaphore¶added inv1.8.0
NewSemaphore returns a semaphore with resource count n.
func (Semaphore)Acquire¶added inv1.8.0
func (sSemaphore) Acquire()
Acquire blocks until a resource is acquired.
func (Semaphore)AcquireContext¶added inv1.8.0
AcquireContext reports whether the resource was acquired before the ctx was done.
func (Semaphore)Len¶added inv1.88.0
Len reports the number of in-flight acquisitions.It is incremented whenever the semaphore is acquired.It is decremented whenever the semaphore is released.
func (Semaphore)TryAcquire¶added inv1.8.0
TryAcquire reports, without blocking, whether the resource was acquired.
typeShardValue¶added inv1.80.0
type ShardValue[Tany] struct {// contains filtered or unexported fields}
ShardValue contains a value sharded over a set of shards.In order to be useful, T should be aligned to cache lines.Users must organize that usage in One and All is concurrency safe.The zero value is not safe for use; useNewShardValue.
funcNewShardValue¶added inv1.80.0
func NewShardValue[Tany]() *ShardValue[T]
NewShardValue constructs a new ShardValue[T] with a shard per CPU.
func (*ShardValue[T])All¶added inv1.80.0
func (sp *ShardValue[T]) All(yield func(*T)bool)
All yields a pointer to the value in each shard.
func (*ShardValue[T])Len¶added inv1.80.0
func (sp *ShardValue[T]) Len()int
Len returns the number of shards.
func (*ShardValue[T])One¶added inv1.80.0
func (sp *ShardValue[T]) One(yield func(*T))
One yields a pointer to a single shard value with best-effort P-locality.
typeShardedInt¶added inv1.80.0
type ShardedInt struct {// contains filtered or unexported fields}ShardedInt provides a sharded atomic int64 value that optimizes highfrequency (Mhz range and above) writes in highly parallel workloads.The zero value is not safe for use; useNewShardedInt.ShardedInt implements the expvar.Var interface.
funcNewShardedInt¶added inv1.80.0
func NewShardedInt() *ShardedInt
NewShardedInt returns a newShardedInt.
func (*ShardedInt)Add¶added inv1.80.0
func (m *ShardedInt) Add(deltaint64)
Add adds delta to the value.
func (*ShardedInt)AppendText¶added inv1.80.0
func (m *ShardedInt) AppendText(b []byte) ([]byte,error)
AppendText implements the encoding.TextAppender interface
func (*ShardedInt)GetDistribution¶added inv1.80.0
func (m *ShardedInt) GetDistribution() []int64
GetDistribution returns the current value in each shard.This is intended for observability/debugging only.
func (*ShardedInt)String¶added inv1.80.0
func (m *ShardedInt) String()string
String implements the expvar.Var interface
func (*ShardedInt)Value¶added inv1.80.0
func (m *ShardedInt) Value()int64
Value returns the current value.
typeShardedMap¶added inv1.46.0
type ShardedMap[Kcomparable, Vany] struct {// contains filtered or unexported fields}
ShardedMap is a synchronized map[K]V, internally sharded by a user-definedK-sharding function.
The zero value is not safe for use; use NewShardedMap.
funcNewShardedMap¶added inv1.46.0
func NewShardedMap[Kcomparable, Vany](shardsint, shard func(K)int) *ShardedMap[K, V]
NewShardedMap returns a new ShardedMap with the given number of shards andsharding function.
The shard func must return a integer in the range [0, shards) purelydeterministically based on the provided K.
func (*ShardedMap[K, V])Contains¶added inv1.46.0
func (m *ShardedMap[K, V]) Contains(key K)bool
Contains reports whether m contains key.
func (*ShardedMap[K, V])Delete¶added inv1.46.0
func (m *ShardedMap[K, V]) Delete(key K) (shrunkbool)
Delete removes key from m.
It reports whether the map size shrunk (that is, whether key was present inthe map).
func (*ShardedMap[K, V])Get¶added inv1.46.0
func (m *ShardedMap[K, V]) Get(key K) (value V)
Get returns m[key] or the zero value of V if key is not present.
func (*ShardedMap[K, V])GetOk¶added inv1.46.0
func (m *ShardedMap[K, V]) GetOk(key K) (value V, okbool)
GetOk returns m[key] and whether it was present.
func (*ShardedMap[K, V])Len¶added inv1.46.0
func (m *ShardedMap[K, V]) Len()int
Len returns the number of elements in m.
It does so by locking shards one at a time, so it's not particularly cheap,nor does it give a consistent snapshot of the map. It's mostly intended formetrics or testing.
func (*ShardedMap[K, V])Mutate¶added inv1.46.0
func (m *ShardedMap[K, V]) Mutate(key K, mutator func(oldValue V, oldValueExistedbool) (newValue V, keepbool)) (sizeDeltaint)
Mutate atomically mutates m[k] by calling mutator.
The mutator function is called with the old value (or its zero value) andwhether it existed in the map and it returns the new value and whether itshould be set in the map (true) or deleted from the map (false).
It returns the change in size of the map as a result of the mutation, one of-1 (delete), 0 (change), or 1 (addition).
func (*ShardedMap[K, V])Set¶added inv1.46.0
func (m *ShardedMap[K, V]) Set(key K, value V) (grewbool)
Set sets m[key] = value.
present in m).
typeWaitGroupChan¶
type WaitGroupChan struct {// contains filtered or unexported fields}WaitGroupChan is like a sync.WaitGroup, but has a chan that closeson completion that you can wait on. (This, you can only use thevalue once)Also, its zero value is not usable. Use the constructor.
funcNewWaitGroupChan¶
func NewWaitGroupChan() *WaitGroupChan
NewWaitGroupChan returns a new single-use WaitGroupChan.
func (*WaitGroupChan)Add¶
func (wg *WaitGroupChan) Add(deltaint)
Add adds delta, which may be negative, to the WaitGroupChancounter. If the counter becomes zero, all goroutines blocked onWait or the Done chan are released. If the counter goes negative,Add panics.
Note that calls with a positive delta that occur when the counteris zero must happen before a Wait. Calls with a negative delta, orcalls with a positive delta that start when the counter is greaterthan zero, may happen at any time. Typically this means the callsto Add should execute before the statement creating the goroutineor other event to be waited for.
func (*WaitGroupChan)Decr¶
func (wg *WaitGroupChan) Decr()
Decr decrements the WaitGroup counter by one.
(It is like sync.WaitGroup's Done method, but we don't use Done inthis type, because it's ambiguous between Context.Done andWaitGroup.Done. So we use DoneChan and Decr instead.)
func (*WaitGroupChan)DoneChan¶
func (wg *WaitGroupChan) DoneChan() <-chan struct{}
DoneChan returns a channel that's closed on completion.
func (*WaitGroupChan)Wait¶
func (wg *WaitGroupChan) Wait()
Wait blocks until the WaitGroupChan counter is zero.
Source Files