Package sync

Overview ▾

包同步提供基本的同步原语,例如互斥锁. 除一次和等待组类型外,大多数都供低级库例程使用. 更高级别的同步最好通过渠道和通信来完成.

包含此包中定义的类型的值不应复制.

type Cond

Cond实现了一个条件变量,它是goroutines等待或宣布事件发生的集合点.

每个Cond都有一个关联的Locker L(通常是* Mutex或* RWMutex),在更改条件和调用Wait方法时必须将其保留.

第一次使用后,不得复制条件.

type Cond struct {

    // L is held while observing or changing the condition
    L Locker
    // contains filtered or unexported fields
}

func NewCond

func NewCond(l Locker) *Cond

NewCond返回带有Locker l的新Cond.

func (*Cond) Broadcast

func (c *Cond) Broadcast()

广播唤醒所有等待c的goroutine.

允许但不要求呼叫者在通话过程中保持cL.

func (*Cond) Signal

func (c *Cond) Signal()

信号唤醒一个等待在c上的goroutine,如果有的话.

允许但不要求呼叫者在通话过程中保持cL.

func (*Cond) Wait

func (c *Cond) Wait()

Wait原子地解锁cL并中止调用goroutine的执行. 稍后恢复执行后,等待锁定cL,然后再返回. 与其他系统不同,等待不会返回,除非被广播或信号唤醒.

因为在等待第一次恢复时cL未被锁定,所以调用者通常无法假定等待返回时条件为真. 而是,调用者应在循环中等待:

c.L.Lock()
for !condition() {
    c.Wait()
}
... make use of condition ...
c.L.Unlock()

type Locker

储物柜表示可以锁定和解锁的对象.

type Locker interface {
    Lock()
    Unlock()
}

type Map 1.9

Map类似于Go map [interface {}] interface {},但是可以安全地被多个goroutine并发使用,而无需额外的锁定或协调. 加载,存储和删除以摊销的固定时间运行.

地图类型是专用的. 大多数代码应改用带有单独锁定或协调功能的普通Go映射,以提高类型安全性并使其更易于维护其他不变式以及映射内容.

Map类型针对两种常见用例进行了优化:(1)给定键的条目仅写入一次但多次读取(例如仅在增长的高速缓存中),或者(2)当多个goroutine进行读取,写入和;覆盖不相交的键集的条目. 在这两种情况下,与与单独的Mutex或RWMutex配对的Go映射相比,使用Map可以显着减少锁争用.

零位图为空,可以使用. 首次使用后不得复制地图.

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

func (*Map) Delete 1.9

func (m *Map) Delete(key interface{})

删除删除键的值.

func (*Map) Load 1.9

func (m *Map) Load(key interface{}) (value interface{}, ok bool)

Load返回存储在映射中的键值;如果不存在任何值,则返回nil. 好的结果表示是否在映射中找到值.

func (*Map) LoadOrStore 1.9

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

LoadOrStore返回键的现有值(如果存在). 否则,它将存储并返回给定值. 如果已加载该值,则加载的结果为true,如果已存储,则为false.

func (*Map) Range 1.9

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

范围依次调用映射中存在的每个键和值. 如果f返回false,则range停止迭代.

Range不一定与Map内容的任何一致快照相对应:不会多次访问任何键,但是如果同时存储或删除任何键的值,Range可能会在Range期间从任何点反映该键的任何映射呼叫.

范围可能是O(N),且映射中的元素数即使在恒定数量的调用后f返回false也是如此.

func (*Map) Store 1.9

func (m *Map) Store(key, value interface{})

Store设置键的值.

type Mutex

互斥锁是互斥锁. 互斥锁的零值是未锁定的互斥锁.

互斥量不得在首次使用后复制.

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

func (*Mutex) Lock

func (m *Mutex) Lock()

锁m. 如果锁已在使用中,则调用goroutine会阻塞,直到互斥体可用为止.

func (*Mutex) Unlock

func (m *Mutex) Unlock()

解锁解锁m. 如果m在进入Unlock时未锁定,则是运行时错误.

锁定的互斥锁与特定的goroutine没有关联. 允许一个goroutine锁定Mutex,然后安排另一个goroutine对其进行解锁.

type Once

一个对象将完全执行一个动作.

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

Example

Only once

func (*Once) Do

func (o *Once) Do(f func())

当且仅当第一次为一次一次的Do实例调用Do时,Do才调用函数f. 换句话说,给定

var once Once

如果多次调用一次do(f),则即使第一个调用的值不同,也只有第一个调用会调用f. 每个函数要执行都需要一个新的一次实例.

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:

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

因为对Do的调用直到返回对f的一次调用才返回,所以如果f导致调用Do,它将死锁.

如果出现紧急情况,Do认为它已经回来; Do的将来调用将不调用而返回f.

type Pool 1.3

池是一组可以单独保存和检索的临时对象.

池中存储的任何项目都可以随时自动删除,恕不另行通知. 如果发生这种情况时,池中只有唯一的引用,则该项目可能会被释放.

池可安全地同时用于多个goroutine.

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.

池的适当用法是管理一组临时项目,这些临时项目在程序包的并发独立客户端之间静默共享并有可能被重用. 池提供了一种摊销许多客户端上的分配开销的方法.

良好使用Pool的一个示例是fmt软件包,该软件包维护着动态大小的临时输出缓冲区存储. 商店在负载下会缩放(当许多goroutine正在主动打印时),并且在静止时会收缩.

另一方面,作为短期对象的一部分维护的空闲列表不适用于Pool,因为在这种情况下开销无法很好地摊销. 让这样的对象实现自己的空闲列表会更有效.

首次使用后不得复制池.

type Pool struct {

    // New optionally specifies a function to generate
    // a value when Get would otherwise return nil.
    // It may not be changed concurrently with calls to Get.
    New func() interface{}
    // contains filtered or unexported fields
}

Example

2006-01-02T15:04:05Z path=/search?q=flowers

func (*Pool) Get 1.3

func (p *Pool) Get() interface{}

Get从池中选择一个任意项目,将其从池中删除,然后将其返回给调用方. Get可以选择忽略池并将其视为空. 调用者不应假定传递给Put的值和Get返回的值之间有任何关系.

如果Get否则返回nil并且p.New不为nil,则Get返回调用p.New的结果.

func (*Pool) Put 1.3

func (p *Pool) Put(x interface{})

Put将x添加到池中.

type RWMutex

RWMutex是读取器/写入器互斥锁. 锁可以由任意数量的读取器或单个写入器持有. RWMutex的零值是未锁定的互斥量.

第一次使用后,不得复制RWMutex.

如果goroutine拥有RWMutex进行读取,而另一个goroutine可能会调用Lock,则在释放初始读取锁之前,任何goroutine都不应期望能够获取读取锁. 特别是,这禁止了递归读取锁定. 这是为了确保锁最终可用. 被锁定的锁定调用将使新读者无法获得锁定.

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

func (*RWMutex) Lock

func (rw *RWMutex) Lock()

Lock锁定rw进行写入. 如果该锁已被锁定以进行读取或写入,则Lock会阻塞直到该锁可用.

func (*RWMutex) RLock

func (rw *RWMutex) RLock()

RLock锁定rw以进行读取.

不应将其用于递归读取锁定. 被锁定的锁定调用将使新读者无法获得锁定. 请参阅有关RWMutex类型的文档.

func (*RWMutex) RLocker

func (rw *RWMutex) RLocker() Locker

RLocker返回一个Locker接口,该接口通过调用rw.RLock和rw.RUnlock来实现Lock和Unlock方法.

func (*RWMutex) RUnlock

func (rw *RWMutex) RUnlock()

RUnlock撤销单个RLock调用; 它不会影响其他同时阅读器. 如果rw在进入RUnlock时未锁定以进行读取,则是运行时错误.

func (*RWMutex) Unlock

func (rw *RWMutex) Unlock()

解锁可解锁读写. 如果在写入"解锁"条目时未锁定rw,则会导致运行时错误.

与互斥锁一样,锁定的RWMutex与特定的goroutine没有关联. 一个goroutine可以RLock(锁定)RWMutex,然后安排另一个goroutine RUnlock(解锁).

type WaitGroup

WaitGroup等待goroutine的集合完成. 主goroutine调用添加以设置要等待的goroutine的数量. 然后,每个goroutine都会运行并在完成后调用Done. 同时,可以使用Wait来阻塞,直到所有goroutine完成.

首次使用后,不得复制WaitGroup.

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

Example

此示例使用WaitGroup阻止并发获取多个URL,直到完成所有获取.

func (*WaitGroup) Add

func (wg *WaitGroup) Add(delta int)

Add将可能为负数的增量添加到WaitGroup计数器中. 如果计数器为零,则释放等待时阻塞的所有goroutine. 如果计数器变为负数,请添加恐慌.

请注意,当计数器为零时发生的增量为正的调用必须在等待之前发生. 在计数器大于零时开始的负增量呼叫或正增量呼叫可能随时发生. 通常,这意味着对Add的调用应在创建goroutine或要等待的其他事件的语句之前执行. 如果重新使用WaitGroup来等待几个独立的事件集,则必须在所有先前的Wait调用返回之后再进行新的Add调用. 请参阅WaitGroup示例.

func (*WaitGroup) Done

func (wg *WaitGroup) Done()

完成将WaitGroup计数器减一.

func (*WaitGroup) Wait

func (wg *WaitGroup) Wait()

等待块,直到WaitGroup计数器为零.

Subdirectories

Name Synopsis
..
atomic 原子包提供了用于实现同步算法的低级原子内存原语.

by  ICOPY.SITE