sync

README

sync

spinLock golang 实现的自旋锁 rwmutex 基于自旋锁实现的读写锁，逻辑参考了golang的读写锁逻辑实现

Documentation

Index

• func NewBlockingKeyCountLimit(n int) *blockingKeyCountLimit
• func NewChanLock() sync.Locker
• func NewSpinLock() sync.Locker
• type Group
  • func (g *Group) Do(key string, dur time.Duration, fn func() (interface{}, error)) (v interface{}, err error, shared bool)
  • func (g *Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result
  • func (g *Group) Forget(key string)
• type RWMutex
  • func (rw *RWMutex) Lock()
  • func (rw *RWMutex) RLock()
  • func (rw *RWMutex) RLocker() sync.Locker
  • func (rw *RWMutex) RUnlock()
  • func (rw *RWMutex) Unlock()
• type Result

Functions

func NewBlockingKeyCountLimit

func NewBlockingKeyCountLimit(n int) *blockingKeyCountLimit

func NewChanLock

func NewChanLock() sync.Locker

func NewSpinLock

func NewSpinLock() sync.Locker

Types

type Group

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

Group represents a class of work and forms a namespace in which units of work can be executed with duplicate suppression.

func (*Group) Do

func (g *Group) Do(key string, dur time.Duration, fn func() (interface{}, error)) (v interface{}, err error, shared bool)

Do executes and returns the results of the given function, making sure that only one execution is in-flight for a given key at a time. If a duplicate comes in, the duplicate caller waits for the original to complete and receives the same results. The return value shared indicates whether v was given to multiple callers.

func (*Group) DoChan

func (g *Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result

DoChan is like Do but returns a channel that will receive the results when they are ready.

func (*Group) Forget

func (g *Group) Forget(key string)

Forget tells the singleflight to forget about a key. Future calls to Do for this key will call the function rather than waiting for an earlier call to complete.

type RWMutex

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

A RWMutex is a reader/writer mutual exclusion lock. The lock can be held by an arbitrary number of readers or a single writer. The zero value for a RWMutex is an unlocked mutex.

A RWMutex must not be copied after first use.

If a goroutine holds a RWMutex for reading and another goroutine might call Lock, no goroutine should expect to be able to acquire a read lock until the initial read lock is released. In particular, this prohibits recursive read locking. This is to ensure that the lock eventually becomes available; a blocked Lock call excludes new readers from acquiring the lock.

func (*RWMutex) Lock

func (rw *RWMutex) Lock()

Lock locks rw for writing. If the lock is already locked for reading or writing, Lock blocks until the lock is available.

func (*RWMutex) RLock

func (rw *RWMutex) RLock()

RLock locks rw for reading.

It should not be used for recursive read locking; a blocked Lock call excludes new readers from acquiring the lock. See the documentation on the RWMutex type.

func (*RWMutex) RLocker

func (rw *RWMutex) RLocker() sync.Locker

RLocker returns a Locker interface that implements the Lock and Unlock methods by calling rw.RLock and rw.RUnlock.

func (*RWMutex) RUnlock

func (rw *RWMutex) RUnlock()

RUnlock undoes a single RLock call; it does not affect other simultaneous readers. It is a run-time error if rw is not locked for reading on entry to RUnlock.

func (*RWMutex) Unlock

func (rw *RWMutex) Unlock()

Unlock unlocks rw for writing. It is a run-time error if rw is not locked for writing on entry to Unlock.

As with Mutexes, a locked RWMutex is not associated with a particular goroutine. One goroutine may RLock (Lock) a RWMutex and then arrange for another goroutine to RUnlock (Unlock) it.

type Result

type Result struct {
	Val    interface{}
	Err    error
	Shared bool
}

Result holds the results of Do, so they can be passed on a channel.