Documentation
¶
Index ¶
- type Barrier
- type CyclicDoubleBarrier
- type DoubleBarrier
- type EtcdSync
- func (d *EtcdSync) Close() error
- func (d *EtcdSync) NewBarrier(key string) Barrier
- func (d *EtcdSync) NewDoubleBarrier(key string, count int) DoubleBarrier
- func (d *EtcdSync) NewElection(electKey string) *concurrency.Election
- func (d *EtcdSync) NewLocker(lockerName string) sync.Locker
- func (d *EtcdSync) NewMutex(mutexName string) Mutex
- func (d *EtcdSync) NewRWMutex(rwMutexName string) RWMutex
- type Map
- func (m *Map[K, V]) CompareAndDelete(key K, old V) (deleted bool)
- func (m *Map[K, V]) CompareAndSwap(key K, old, new V) bool
- 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 any, loaded bool)
- func (m *Map[K, V]) Range(f func(key K, value V) bool)
- func (m *Map[K, V]) Store(key K, value V)
- func (m *Map[K, V]) Swap(key K, value V) (previous V, loaded bool)
- type Mutex
- type RWMutex
- type ReentrantMutex
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Barrier ¶
type Barrier interface {
// Hold 创建栅栏的key,让当前goroutine阻塞在Wait方法调用上.
Hold() error
// Release 解锁阻塞的goroutine.
Release() error
// Wait 阻塞在栅栏key上，直到它被删除.
Wait() error
}
Barrier 代表一个分布式栅栏对象,类似标准库中的sync.WaitGroup,可以实现分布式的任务编排.
type CyclicDoubleBarrier ¶
type CyclicDoubleBarrier struct {
// contains filtered or unexported fields
}
CyclicDoubleBarrier is a synchronizer that allows a set of goroutines to wait for each other to enter, and wait for each other to leave.
func NewCyclicDoubleBarrier ¶
func NewCyclicDoubleBarrier(parties int) *CyclicDoubleBarrier
NewCyclicDoubleBarrier 新建一个可重用的双次栅栏 CyclicDoubleBarrier.
func (*CyclicDoubleBarrier) Enter ¶
func (b *CyclicDoubleBarrier) Enter(ctx context.Context)
Enter 等待 parties goroutine进入.
func (*CyclicDoubleBarrier) Leave ¶
func (b *CyclicDoubleBarrier) Leave(ctx context.Context)
Leave 等待 parties goroutine离开.
type DoubleBarrier ¶
type DoubleBarrier interface {
// Enter 等待"count"个goroutine进入才返回.
Enter() error
// Leave 等待"count"个goroutine调用Leave才返回.
Leave() error
}
Barrier 代表一个分布式双次栅栏对象. 所有的分布式goroutine都会阻塞在Enter方法调用上，直到指定数量的goroutine调用了; 然后又会阻塞在Leave方法调用上，直到所有的goroutine都调用了Leave方法.
type EtcdSync ¶
type EtcdSync struct {
// contains filtered or unexported fields
}
EtcEtcdSync 代表一个基于Redis的分布式并发原语管理器，底层维护和etcd的连接. 通过它可以得到各种分布式的并发原语.
func NewEtcdSync ¶
func NewEtcdSync(config clientv3.Config, opts ...concurrency.SessionOption) (*EtcdSync, error)
NewEtcdSync 返回一个新的EtcdSync对象.
func (*EtcdSync) NewBarrier ¶
NewBarrier 返回一个栅栏对象. Barrier creates a key in etcd to block processes, then deletes the key to release all blocked processes.
func (*EtcdSync) NewDoubleBarrier ¶
func (d *EtcdSync) NewDoubleBarrier(key string, count int) DoubleBarrier
NewBarrier 返回一个双次栅栏对象.
func (*EtcdSync) NewElection ¶
func (d *EtcdSync) NewElection(electKey string) *concurrency.Election
NewElection 返回一个etcd Election 对象.
func (*EtcdSync) NewRWMutex ¶
NewBarrier 返回一个栅栏对象. Barrier creates a key in etcd to block processes, then deletes the key to release all blocked processes.
type Map ¶
type Map[K comparable, V any] struct { // contains filtered or unexported fields }
Map is like a Go map[interface{}]interface{} but is safe for concurrent use by multiple goroutines without additional locking or coordination. Loads, stores, and deletes run in amortized constant time.
The Map type is specialized. Most code should use a plain Go map instead, with separate locking or coordination, for better type safety and to make it easier to maintain other invariants along with the map content.
The Map type is optimized for two common use cases: (1) when the entry for a given key is only ever written once but read many times, as in caches that only grow, or (2) when multiple goroutines read, write, and overwrite entries for disjoint sets of keys. In these two cases, use of a Map may significantly reduce lock contention compared to a Go map paired with a separate Mutex or RWMutex.
The zero Map is empty and ready for use. A Map must not be copied after first use.
In the terminology of the Go memory model, Map arranges that a write operation “synchronizes before” any read operation that observes the effect of the write, where read and write operations are defined as follows. Load, LoadAndDelete, LoadOrStore, Swap, CompareAndSwap, and CompareAndDelete are read operations; Delete, LoadAndDelete, Store, and Swap are write operations; LoadOrStore is a write operation when it returns loaded set to false; CompareAndSwap is a write operation when it returns swapped set to true; and CompareAndDelete is a write operation when it returns deleted set to true.
func (*Map[K, V]) CompareAndDelete ¶
CompareAndDelete deletes the entry for key if its value is equal to old. The old value must be of a comparable type.
If there is no current value for key in the map, CompareAndDelete returns false (even if the old value is the nil interface value).
func (*Map[K, V]) CompareAndSwap ¶
CompareAndSwap swaps the old and new values for key if the value stored in the map is equal to old. The old value must be of a comparable type.
func (*Map[K, V]) Load ¶
Load returns the value stored in the map for a key, or nil if no value is present. The ok result indicates whether value was found in the map.
func (*Map[K, V]) LoadAndDelete ¶
LoadAndDelete deletes the value for a key, returning the previous value if any. The loaded result reports whether the key was present.
func (*Map[K, V]) LoadOrStore ¶
LoadOrStore returns the existing value for the key if present. Otherwise, it stores and returns the given value. The loaded result is true if the value was loaded, false if stored.
func (*Map[K, V]) Range ¶
Range calls f sequentially for each key and value present in the map. If f returns false, range stops the iteration.
Range does not necessarily correspond to any consistent snapshot of the Map's contents: no key will be visited more than once, but if the value for any key is stored or deleted concurrently (including by f), Range may reflect any mapping for that key from any point during the Range call. Range does not block other methods on the receiver; even f itself may call any method on m.
Range may be O(N) with the number of elements in the map even if f returns false after a constant number of calls.
type Mutex ¶
type Mutex interface {
// TryLock locks the mutex if not already locked by another session.
TryLock(ctx context.Context) error
// Lock locks the mutex with a cancelable context.
Lock(ctx context.Context) error
// Unlock unlocks the mutex with a cancelable context.
Unlock(ctx context.Context) error
// IsOwner returns whether current session holds this mutex.
IsOwner() bool
}
Mutex 代表一个排他锁对象，比sync.Locker更多的方法.
type RWMutex ¶
type RWMutex interface {
// Lock locks rw for writing.
Lock() error
// Unlock unlocks rw for writing.
Unlock() error
// RLock locks rw for reading.
RLock() error
// RUnlock undoes a single RLock call;
RUnlock() error
}
RWMutex is a reader/writer mutual exclusion lock.
type ReentrantMutex ¶
ReentrantLock is held by the goroutine last successfully locking, but not yet unlocking it.
func (*ReentrantMutex) Lock ¶
func (m *ReentrantMutex) Lock()
Lock locks m. If the lock is already in use, the calling goroutine blocks until the mutex is available.
func (*ReentrantMutex) Unlock ¶
func (m *ReentrantMutex) Unlock()
Unlock unlocks m. It is a run-time error if m is not locked on entry to Unlock.
This lock must be unlock by the held goroutine, not like Mutex in the standard lib.
Source Files