Documentation
¶
Index ¶
- type Counter
- func (c *Counter) Decrease() (newValue int)
- func (c *Counter) Get() (value int)
- func (c *Counter) Increase() (newValue int)
- func (c *Counter) Set(newValue int) (oldValue int)
- func (c *Counter) Subscribe(subscribers ...func(oldValue, newValue int)) (unsubscribe func())
- func (c *Counter) Update(delta int) (newValue int)
- func (c *Counter) WaitIsAbove(threshold int)
- func (c *Counter) WaitIsBelow(threshold int)
- func (c *Counter) WaitIsZero()
- type DAGMutex
- type Mutex
- type RWMutex
- type RWMutexFake
- type Stack
- func (b *Stack[T]) Pop() (element T, success bool)
- func (b *Stack[T]) PopOrWait(waitCondition func() bool) (element T, success bool)
- func (b *Stack[T]) Push(task T)
- func (b *Stack[T]) SignalShutdown()
- func (b *Stack[T]) Size() int
- func (b *Stack[T]) WaitIsEmpty()
- func (b *Stack[T]) WaitSizeIsAbove(threshold int)
- func (b *Stack[T]) WaitSizeIsBelow(threshold int)
- type StarvingMutex
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Counter ¶
type Counter struct {
// contains filtered or unexported fields
}
func NewCounter ¶
func NewCounter() (newCounter *Counter)
func (*Counter) WaitIsAbove ¶
func (*Counter) WaitIsBelow ¶
func (*Counter) WaitIsZero ¶
func (c *Counter) WaitIsZero()
type DAGMutex ¶
type DAGMutex[T comparable] struct { sync.Mutex // contains filtered or unexported fields }
DAGMutex is a multi-entity reader/writer mutual exclusion lock that allows for starvation. Entities can be registered dynamically by providing a comparable identifier. The structure and relation of these entities MUST NOT contain any cycles as this may lead to deadlocks while waiting to acquire locks cyclically.
Entities can be Lock-ed one at a time. The call blocks until the lock for this entity can be acquired. Entities can be RLock-ed multiple in arbitrary order. The call blocks until all read locks can be acquired.
Consider the following example of a DAG with 3 entities A,B,C. ┌───┬─┐ │ │B◄─┐ ┌▼┐ └─┘ │ │A│ │ └▲┘ ┌┴┐ │ │C│ └──────┴─┘
Let's assume the following 3 goroutines are competing for access. Time is advancing with every row. Goroutine 1 Goroutine 2 Goroutine 3
Lock(A) - RLock(A,B) <- blocking, not able to acquire locks
work Lock(B) wait
Unlock(A) work wait
- Unlock(B) wait <- (internally) now RLock(A) is successful, but still waiting for B
- - RLock(A, B) <- successful acquired, holding the locks now
func NewDAGMutex ¶
func NewDAGMutex[T comparable]() *DAGMutex[T]
NewDAGMutex creates a new DAGMutex.
func (*DAGMutex[T]) Lock ¶
func (d *DAGMutex[T]) Lock(id T)
Lock locks the given entity for writing. If the lock is already locked for reading or writing, Lock blocks until the lock is available.
func (*DAGMutex[T]) RLock ¶
func (d *DAGMutex[T]) RLock(ids ...T)
RLock locks all given entities for reading. It blocks until all read locks can be acquired.
It should not be used for recursive read locking. A blocked Lock call DOES NOT exclude new readers from acquiring the lock. Hence, it is starving.
func (*DAGMutex[T]) RUnlock ¶
func (d *DAGMutex[T]) RUnlock(ids ...T)
RUnlock unlocks reading for all given entities. It does not affect other simultaneous readers.
func (*DAGMutex[T]) Unlock ¶
func (d *DAGMutex[T]) Unlock(id T)
Unlock unlocks the given entity for writing.
As with Mutexes, a locked DAGMutex is not associated with a particular goroutine. One goroutine may RLock (Lock) an entity within DAGMutex and then arrange for another goroutine to RUnlock (Unlock) it.
type RWMutexFake ¶
func (*RWMutexFake) RLock ¶
func (m *RWMutexFake) RLock()
func (*RWMutexFake) RUnlock ¶
func (m *RWMutexFake) RUnlock()
type Stack ¶
type Stack[T any] struct { // contains filtered or unexported fields }
func (*Stack[T]) SignalShutdown ¶
func (b *Stack[T]) SignalShutdown()
func (*Stack[T]) WaitIsEmpty ¶
func (b *Stack[T]) WaitIsEmpty()
func (*Stack[T]) WaitSizeIsAbove ¶
func (*Stack[T]) WaitSizeIsBelow ¶
type StarvingMutex ¶
type StarvingMutex struct {
// contains filtered or unexported fields
}
A StarvingMutex is a reader/writer mutual exclusion lock that allows for starvation of readers or writers by first prioritizing any outstanding reader or writer depending on the current mode (continue reading or continue writing). The lock can be held by an arbitrary number of readers or a single writer. The zero value for a StarvingMutex is an unlocked mutex.
A StarvingMutex must not be copied after first use.
If a goroutine holds a StarvingMutex for reading and another goroutine might call Lock, other goroutines can acquire a read lock. This allows recursive read locking. However, this can result in starvation of goroutines that tried to acquire write lock on the mutex. A blocked Lock call does not exclude new readers from acquiring the lock.
func NewStarvingMutex ¶
func NewStarvingMutex() *StarvingMutex
NewStarvingMutex creates a new StarvingMutex.
func (*StarvingMutex) Lock ¶
func (f *StarvingMutex) Lock()
Lock locks starving mutex for writing. If the lock is already locked for reading or writing, Lock blocks until the lock is available.
If there are waiting writers these will be served first before ANY reader can read again. Hence, it is starving.
func (*StarvingMutex) RLock ¶
func (f *StarvingMutex) RLock()
RLock locks starving mutex for reading.
It should not be used for recursive read locking. A blocked Lock call DOES NOT exclude new readers from acquiring the lock. Hence, it is starving.
func (*StarvingMutex) RUnlock ¶
func (f *StarvingMutex) RUnlock()
RUnlock undoes a single RLock call; it does not affect other simultaneous readers. It is a run-time error if mutex is not locked for reading on entry to RUnlock.
func (*StarvingMutex) String ¶
func (f *StarvingMutex) String() (humanReadable string)
String returns a string representation of the StarvingMutex.
func (*StarvingMutex) Unlock ¶
func (f *StarvingMutex) Unlock()
Unlock unlocks starving mutex for writing. It is a run-time error if mutex is not locked for writing on entry to Unlock.
As with Mutexes, a locked StarvingMutex is not associated with a particular goroutine. One goroutine may RLock (Lock) a StarvingMutex and then arrange for another goroutine to RUnlock (Unlock) it.
Source Files