ActiveGo 1.8Package syncutil
Overview ▹
Index ▹
type Gate ¶
A Gate limits concurrency.
type Gate struct {
// contains filtered or unexported fields
}
func NewGate ¶
func NewGate(max int) *Gate
NewGate returns a new gate that will only permit max operations at once.
func (*Gate) Done ¶
func (g *Gate) Done()
Done finishes an operation.
func (*Gate) Start ¶
func (g *Gate) Start()
Start starts an operation, blocking until the gate has room.
type Group ¶
A Group is like a sync.WaitGroup and coordinates doing multiple things at once. Its zero value is ready to use.
type Group struct {
// contains filtered or unexported fields
}
func (*Group) Err ¶
func (g *Group) Err() error
Err waits for all previous calls to Go to complete and returns the first non-nil error, or nil.
func (*Group) Errs ¶
func (g *Group) Errs() []error
Errs waits for all previous calls to Go to complete and returns all non-nil errors.
func (*Group) Go ¶
func (g *Group) Go(fn func() error)
Go runs fn in its own goroutine, but does not wait for it to complete. Call Err or Errs to wait for all the goroutines to complete.
func (*Group) Wait ¶
func (g *Group) Wait()
Wait waits for all the previous calls to Go to complete.
type Once ¶
A Once will perform a successful action exactly once.
Unlike a sync.Once, this Once's func returns an error and is re-armed on failure.
type Once struct {
// contains filtered or unexported fields
}
func (*Once) Do ¶
func (o *Once) Do(f func() error) error
Do calls the function f if and only if Do has not been invoked without error for this instance of Once. In other words, given
var once Once
if once.Do(f) is called multiple times, only the first call will invoke f, even if f has a different value in each invocation unless f returns an error. A new instance of Once is required for each function to execute.
Do is intended for initialization that must be run exactly once. Since f is niladic, it may be necessary to use a function literal to capture the arguments to a function to be invoked by Do:
err := config.once.Do(func() error { return config.init(filename) })
type Sem ¶
Sem implements a semaphore that can have multiple units acquired/released at a time.
type Sem struct {
// contains filtered or unexported fields
}
func NewSem ¶
func NewSem(max int64) *Sem
NewSem creates a semaphore with max units available for acquisition.
func (*Sem) Acquire ¶
func (s *Sem) Acquire(n int64) error
Acquire will deduct n units from the semaphore. If the deduction would result in the available units falling below zero, the call will block until another go routine returns units via a call to Release. If more units are requested than the semaphore is configured to hold, error will be non-nil.
func (*Sem) Release ¶
func (s *Sem) Release(n int64)
Release will return n units to the semaphore and notify any currently blocking Acquire calls.
Subdirectories
| Name | Synopsis |
|---|---|
| .. | |
| singleflight | Package singleflight provides a duplicate function call suppression mechanism. |
| syncdebug | Package syncdebug contains facilities for debugging synchronization problems. |