cilium: github.com/cilium/cilium/pkg/lock Index | Files

package lock

import "github.com/cilium/cilium/pkg/lock"

Index

Package Files

lock.go lock_fast.go semaphored_mutex.go stoppable_waitgroup.go

type Mutex Uses

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

Mutex is equivalent to sync.Mutex but applies deadlock detection if the built tag "lockdebug" is set

func (*Mutex) UnlockIgnoreTime Uses

func (i *Mutex) UnlockIgnoreTime()

type MutexDebug Uses

type MutexDebug struct {
    deadlock.Mutex
}

MutexDebug is a MutexDebug with deadlock detection regardless of use of the build tag

type RWMutex Uses

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

RWMutex is equivalent to sync.RWMutex but applies deadlock detection if the built tag "lockdebug" is set

func (*RWMutex) UnlockIgnoreTime Uses

func (i *RWMutex) UnlockIgnoreTime()

type RWMutexDebug Uses

type RWMutexDebug struct {
    deadlock.RWMutex
}

RWMutexDebug is a RWMutexDebug with deadlock detection regardless of use of the build tag

type SemaphoredMutex Uses

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

SemaphoredMutex is a semaphored mutex that provides a RWLocker interface.

func NewSemaphoredMutex Uses

func NewSemaphoredMutex() SemaphoredMutex

NewSemaphoredMutex returns a new SemaphoredMutex.

func (*SemaphoredMutex) Lock Uses

func (i *SemaphoredMutex) Lock()

func (*SemaphoredMutex) RLock Uses

func (i *SemaphoredMutex) RLock()

func (*SemaphoredMutex) RUnlock Uses

func (i *SemaphoredMutex) RUnlock()

func (*SemaphoredMutex) Unlock Uses

func (i *SemaphoredMutex) Unlock()

func (*SemaphoredMutex) UnlockToRLock Uses

func (i *SemaphoredMutex) UnlockToRLock()

UnlockToRLock releases the current lock for writing but it still keeps it for reading purposes.

type StoppableWaitGroup Uses

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

A StoppableWaitGroup waits for a collection of goroutines to finish.

func NewStoppableWaitGroup Uses

func NewStoppableWaitGroup() *StoppableWaitGroup

NewStoppableWaitGroup returns a new StoppableWaitGroup. When the 'Stop' is executed, following 'Add()' calls won't have any effect.

func (*StoppableWaitGroup) Add Uses

func (l *StoppableWaitGroup) Add()

Add adds the go routine to the list of routines to that Wait() will have to wait before it returns. If the StoppableWaitGroup was stopped this will be a no-op.

func (*StoppableWaitGroup) Done Uses

func (l *StoppableWaitGroup) Done()

Done will decrement the number of go routines the Wait() will have to wait before it returns. This function is a no-op once all go routines that have called 'Add()' have also called 'Done()' and the StoppableWaitGroup was stopped.

func (*StoppableWaitGroup) Stop Uses

func (l *StoppableWaitGroup) Stop()

Stop makes following 'Add()' to be considered a no-op. If all goroutines that have called Add also called Done, 'Wait()' will be immediately unblocked.

func (*StoppableWaitGroup) Wait Uses

func (l *StoppableWaitGroup) Wait()

Wait will return once all goroutines that have called Add also called Done and StoppableWaitGroup was stopped. Internally, Wait() returns once the internal counter becomes negative.

func (*StoppableWaitGroup) WaitChannel Uses

func (l *StoppableWaitGroup) WaitChannel() <-chan struct{}

WaitChannel will return a channel that will be closed once all goroutines that have called Add also called Done and StoppableWaitGroup was stopped.

Package lock imports 5 packages (graph) and is imported by 296 packages. Updated 2020-05-23. Refresh now. Tools for package owners.