Overview

Package sync provides basic synchronization primitives such as mutual exclusion
locks. Other than the Once and WaitGroup types, most are intended for use by
low-level library routines. Higher-level synchronization is better done via
channels and communication.

Values containing the types defined in this package should not be copied.

Index

Package files

cond.go mutex.go pool.go rwmutex.go

type Cond

Cond implements a condition variable, a rendezvous point for goroutines waiting
for or announcing the occurrence of an event.

Each Cond has an associated Locker L (often a Mutex or RWMutex), which must be
held when changing the condition and when calling the Wait method.

A Cond must not be copied after first use.

func NewCond

  1. func NewCond(l Locker) *

NewCond returns a new Cond with Locker l.

func (*Cond) Broadcast

  1. func (c *Cond) Broadcast()

Broadcast wakes all goroutines waiting on c.

It is allowed but not required for the caller to hold c.L during the call.

func (*Cond) 

  1. func (c *) Signal()

Signal wakes one goroutine waiting on c, if there is any.

It is allowed but not required for the caller to hold c.L during the call.

func (*Cond) Wait

  1. func (c *Cond) Wait()

Wait atomically unlocks c.L and suspends execution of the calling goroutine.
After later resuming execution, Wait locks c.L before returning. Unlike in other
systems, Wait cannot return unless awoken by Broadcast or Signal.

Because c.L is not locked when Wait first resumes, the caller typically cannot
assume that the condition is true when Wait returns. Instead, the caller should
Wait in a loop:

  1. c.L.Lock()
  2. for !condition() {
  3.     c.Wait()
  4. }
  5. ... make use of condition ...
  6. c.L.Unlock()

  1. type Locker interface {
  2.     Lock()
  3.     Unlock()
  4. }

A Locker represents an object that can be locked and unlocked.

type 

  1. type Map struct {
  2.     // contains filtered or unexported fields
  3. }

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.

func (*Map) 

  1. func (m *) Delete(key interface{})

Delete deletes the value for a key.

func (*Map) 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.

    1. func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded )

    func (*Map) Range

    1. func (m *Map) Range(f func(key, value interface{}) )

    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, Range may reflect any mapping for that key from
    any point during the Range call.

    Range may be O(N) with the number of elements in the map even if f returns false
    after a constant number of calls.

    func (*Map) Store

    Store sets the value for a key.

    type Mutex

    1. type Mutex struct {
    2.     // contains filtered or unexported fields
    3. }

    A Mutex is a mutual exclusion lock. The zero value for a Mutex is an unlocked
    mutex.

    A Mutex must not be copied after first use.

    func (*Mutex) Lock

    1. func (m *Mutex) Lock()

    Lock locks m. If the lock is already in use, the calling goroutine blocks until
    the mutex is available.

    func (*Mutex) 

    1. func (m *) Unlock()

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

    A locked Mutex is not associated with a particular goroutine. It is allowed for
    one goroutine to lock a Mutex and then arrange for another goroutine to unlock
    it.

    type Once

    1. type Once struct {
    2.     // contains filtered or unexported fields
    3. }

    Once is an object that will perform exactly one action.


    Example:

    1. var once sync.Once
    2. onceBody := func() {
    3.     fmt.Println("Only once")
    4. }
    5. done := make(chan bool)
    6. for i := 0; i < 10; i++ {
    7.     go func() {
    8.         once.Do(onceBody)
    9.         done <- true
    10.     }()
    11. }
    12. for i := 0; i < 10; i++ {
    13.     <-done
    14. }
    15. // Output:
    16. // Only once

    func (*Once) 

    1. func (o *) Do(f func())

    Do calls the function f if and only if Do is being called for the first time for
    this instance of Once. In other words, given

    1. 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. 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:

    1. config.once.Do(func() { config.init(filename) })

    Because no call to Do returns until the one call to f returns, if f causes Do to
    be called, it will deadlock.

    If f panics, Do considers it to have returned; future calls of Do return without
    calling f.

    1. type Pool struct {
    2.  
    3.     // New optionally specifies a function to generate
    4.     // a value when Get would otherwise return nil.
    5.     // It may not be changed concurrently with calls to Get.
    6.     New func() interface{}
    7.     // contains filtered or unexported fields
    8. }

    A Pool is a set of temporary objects that may be individually saved and
    retrieved.

    Any item stored in the Pool may be removed automatically at any time without
    notification. If the Pool holds the only reference when this happens, the item
    might be deallocated.

    A Pool is safe for use by multiple goroutines simultaneously.

    Pool’s purpose is to cache allocated but unused items for later reuse, relieving
    pressure on the garbage collector. That is, it makes it easy to build efficient,
    thread-safe free lists. However, it is not suitable for all free lists.

    An appropriate use of a Pool is to manage a group of temporary items silently
    shared among and potentially reused by concurrent independent clients of a
    package. Pool provides a way to amortize allocation overhead across many
    clients.

    An example of good use of a Pool is in the fmt package, which maintains a
    dynamically-sized store of temporary output buffers. The store scales under load
    (when many goroutines are actively printing) and shrinks when quiescent.

    On the other hand, a free list maintained as part of a short-lived object is not
    a suitable use for a Pool, since the overhead does not amortize well in that
    scenario. It is more efficient to have such objects implement their own free
    list.

    A Pool must not be copied after first use.


    Example:

    1. package sync_test
    3. import (
    5.     "io"
    6.     "os"
    7.     "sync"
    8.     "time"
    9. )
    11. var bufPool = sync.Pool{
    12.     New: func() interface{} {
    13.         // The Pool's New function should generally only return pointer
    14.         // types, since a pointer can be put into the return interface
    15.         // value without an allocation:
    16.         return new(bytes.Buffer)
    17.     },
    18. }
    20. func timeNow() time.Time {
    21.     return time.Unix(1136214245, 0)
    22. }
    24. func Log(w io.Writer, key, val string) {
    25.     b := bufPool.Get().(*bytes.Buffer)
    26.     b.Reset()
    27.     // Replace this with time.Now() in a real logger.
    28.     b.WriteString(timeNow().UTC().Format(time.RFC3339))
    29.     b.WriteByte(' ')
    30.     b.WriteString(key)
    32.     b.WriteString(val)
    33.     w.Write(b.Bytes())
    34.     bufPool.Put(b)
    35. }
    37. func ExamplePool() {
    38.     Log(os.Stdout, "path", "/search?q=flowers")
    39.     // Output: 2006-01-02T15:04:05Z path=/search?q=flowers
    40. }

    func (*Pool) 

    1. func (p *) Get() interface{}

    Get selects an arbitrary item from the Pool, removes it from the Pool, and
    returns it to the caller. Get may choose to ignore the pool and treat it as
    empty. Callers should not assume any relation between values passed to Put and
    the values returned by Get.

    If Get would otherwise return nil and p.New is non-nil, Get returns the result
    of calling p.New.

    func (*Pool) Put

    Put adds x to the pool.

    type RWMutex

    1. type RWMutex struct {
    2.     // contains filtered or unexported fields
    3. }

    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.

    1. 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) 

    1. func (rw *) 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

    1. func (rw *RWMutex) RLocker()

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

    func (*RWMutex) RUnlock

    1. 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) 

    1. func (rw *) 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 WaitGroup

    1. type WaitGroup struct {
    2.     // contains filtered or unexported fields
    3. }

    A WaitGroup waits for a collection of goroutines to finish. The main goroutine
    calls Add to set the number of goroutines to wait for. Then each of the
    goroutines runs and calls Done when finished. At the same time, Wait can be used
    to block until all goroutines have finished.

    A WaitGroup must not be copied after first use.


    Example:

    1. var wg sync.WaitGroup
    2. var urls = []string{
    3.     "http://www.golang.org/",
    4.     "http://www.google.com/",
    5.     "http://www.somestupidname.com/",
    6. }
    7. for _, url := range urls {
    8.     // Increment the WaitGroup counter.
    9.     wg.Add(1)
    10.     // Launch a goroutine to fetch the URL.
    11.     go func(url string) {
    12.         // Decrement the counter when the goroutine completes.
    13.         defer wg.Done()
    14.         // Fetch the URL.
    15.         http.Get(url)
    16.     }(url)
    17. }
    18. // Wait for all HTTP fetches to complete.

    func (*WaitGroup) 

    1. func (wg *) Add(delta int)

    Add adds delta, which may be negative, to the WaitGroup counter. If the counter
    becomes zero, all goroutines blocked on Wait are released. If the counter goes
    negative, Add panics.

    Note that calls with a positive delta that occur when the counter is zero must
    happen before a Wait. Calls with a negative delta, or calls with a positive
    delta that start when the counter is greater than zero, may happen at any time.
    Typically this means the calls to Add should execute before the statement
    creating the goroutine or other event to be waited for. If a WaitGroup is reused
    to wait for several independent sets of events, new Add calls must happen after
    all previous Wait calls have returned. See the WaitGroup example.

    func (*WaitGroup) 

    1. func (wg *) Done()

    Done decrements the WaitGroup counter by one.

    func (*WaitGroup) Wait

    1. func (wg *WaitGroup) Wait()

    Wait blocks until the WaitGroup counter is zero.

    Subdirectories