golang 源码分析之sync
sync 同步
sync.Mutex
sync.RWMutex
sync.WaitGroup
sync.Once
sync.Cond
Mutex
// A Mutex must not be copied after first use.
type Mutex struct {
state int32
sema uint32
}
mutex.Lock()
func (m *Mutex) Lock() {
// 先看看能不能直接获取到
if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
if race.Enabled {
race.Acquire(unsafe.Pointer(m))
}
// 能就直接返回
return
}
// 不能直接获取到就调用lockSlow 慢慢获取
m.lockSlow()
}
lockSlow()
func (m *Mutex) lockSlow() {
var waitStartTime int64
starving := false
awoke := false
iter := 0
old := m.state
for {
// 不是饥饿模式下尝试通过自旋获取
//runtime_canSpin为true的条件
//1运行在多 CPU 的机器上
//2当前 Goroutine 为了获取该锁进入自旋的次数小于四次
//3当前机器上至少存在一个正在运行的处理器 P 并且处理的运行队列为空
if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
awoke = true
}
runtime_doSpin()
iter++
old = m.state
continue
}
new := old
// Don't try to acquire starving mutex, new arriving goroutines must queue.
if old&mutexStarving == 0 {
new |= mutexLocked
}
if old&(mutexLocked|mutexStarving) != 0 {
new += 1 << mutexWaiterShift
}
// 切换为饥饿模式
if starving && old&mutexLocked != 0 {
new |= mutexStarving
}
if awoke {
// 被唤醒
if new&mutexWoken == 0 {
throw("sync: inconsistent mutex state")
}
new &^= mutexWoken
}
//通过cas获取锁
if atomic.CompareAndSwapInt32(&m.state, old, new) {
if old&(mutexLocked|mutexStarving) == 0 {
break // locked the mutex with CAS
}
// 如果之前已经在等待，就在队列的最前面等待.
queueLifo := waitStartTime != 0
if waitStartTime == 0 {
waitStartTime = runtime_nanotime()
}
// 休眠
runtime_SemacquireMutex(&m.sema, queueLifo, 1)
starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
old = m.state
if old&mutexStarving != 0 {
// 如果被唤醒了并且互斥锁处于饥饿状态，那么我们就是饥饿模式下的管理者
if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
throw("sync: inconsistent mutex state")
}
delta := int32(mutexLocked - 1<<mutexWaiterShift)
if !starving || old>>mutexWaiterShift == 1 {
// 退出饥饿模式
delta -= mutexStarving
}
atomic.AddInt32(&m.state, delta)
break
}
awoke = true
iter = 0
} else {
old = m.state
}
}
if race.Enabled {
race.Acquire(unsafe.Pointer(m))
}
}
如果互斥锁处于初始化状态，就会直接通过置位 mutexLocked 加锁；
如果互斥锁处于 mutexLocked 并且在普通模式下工作，就会进入自旋，执行 30 次 PAUSE 指令消耗 CPU 时间等待锁的释放；
如果当前 Goroutine 等待锁的时间超过了 1ms，互斥锁就会切换到饥饿模式；
互斥锁在正常情况下会通过 sync.runtime_SemacquireMutex 函数将尝试获取锁的 Goroutine 切换至休眠状态，等待锁的持有者唤醒当前 Goroutine；
如果当前 Goroutine 是互斥锁上的最后一个等待的协程或者等待的时间小于 1ms，当前 Goroutine 会将互斥锁切换回正常模式；
mutex.UnLock()
func (m *Mutex) Unlock() {
//如果该函数返回的新状态等于 0，当前 Goroutine 就成功解锁了互斥锁；
//如果该函数返回的新状态不等于 0，这段代码会调用 sync.Mutex.unlockSlow 方法开始慢速解锁：
if race.Enabled {
_ = m.state
race.Release(unsafe.Pointer(m))
}
// 快速解锁
new := atomic.AddInt32(&m.state, -mutexLocked)
if new != 0 {
//在正常模式下如果互斥锁不存在等待者或者互斥锁的 mutexLocked、mutexStarving、mutexWoken 状态不都为 0，那么当前方法就可以直接返回，不需要唤醒其他等待者；
//在正常模式下如果互斥锁存在等待者，会通过 sync.runtime_Semrelease 唤醒等待者并移交锁的所有权；
//在饥饿模式下，代码会直接调用 sync.runtime_Semrelease 方法将当前锁交给下一个正在尝试获取锁的等待者，等待者被唤醒后会得到锁，在这时互斥锁还不会退出饥饿状态；
m.unlockSlow(new)
}
}
RWMutex
type RWMutex struct {
w Mutex // 复用mutex
writerSem uint32 // 写等待读
readerSem uint32 // 读等待写
readerCount int32 // 正在执行的读操作个数
readerWait int32 // 写操作阻塞了之后读操作的等待个数
}
RWMutex.Lock()
func (rw *RWMutex) Lock() {
// 锁上 只能一个写进入
rw.w.Lock()
// 标记 有写在等待
r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
// 等待之前的读操作执行完
if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
runtime_SemacquireMutex(&rw.writerSem, false, 0)
}
}
RWMutex.UnLock()
func (rw *RWMutex) Unlock() {
// 可以执行读操作了
r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
if r >= rwmutexMaxReaders {
race.Enable()
throw("sync: Unlock of unlocked RWMutex")
}
// 通过 for 循环触发所有由于获取读锁而陷入等待的 Goroutine：
for i := 0; i < int(r); i++ {
runtime_Semrelease(&rw.readerSem, false, 0)
}
// 释放锁
rw.w.Unlock()
}
RWMutex.RLock()
func (rw *RWMutex) RLock() {
//如果该方法返回负数 — 其他 Goroutine 获得了写锁，当前 Goroutine 就会调用 sync.runtime_SemacquireMutex 陷入休眠等待锁的释放；
//如果该方法的结果为非负数 — 没有 Goroutine 获得写锁，当前方法就会成功返回；
if atomic.AddInt32(&rw.readerCount, 1) < 0 {
// A writer is pending, wait for it.
runtime_SemacquireMutex(&rw.readerSem, false, 0)
}
}
RWMutex.RUnlock()
func (rw *RWMutex) RUnlock() {
//如果返回值大于等于零 — 读锁直接解锁成功；
//如果返回值小于零 — 有一个正在执行的写操作，在这时会调用sync.RWMutex.rUnlockSlow 方法；
//sync.RWMutex.rUnlockSlow 会减少获取锁的写操作等待的读操作数 readerWait 并在所有读操作都被释放之后触发写操作的信号量 writerSem，该信号量被触发时，调度器就会唤醒尝试获取写锁的 Goroutine。
if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
// Outlined slow-path to allow the fast-path to be inlined
rw.rUnlockSlow(r)
}
}
WaitGroup
type WaitGroup struct {
// 不能通过再拷贝的方式赋值
noCopy noCopy
//状态和信号量
state1 [3]uint32
}
WaitGroup.Add()
func (wg *WaitGroup) Add(delta int) {
// 获取状态和信号量，因为state1 在32和64系统里代表不一样的，所以有个方法来获取状态和信号量
statep, semap := wg.state()
// 增加
state := atomic.AddUint64(statep, uint64(delta)<<32)
v := int32(state >> 32)
w := uint32(state)
// 总数小于0 panic
if v < 0 {
panic("sync: negative WaitGroup counter")
}
//
if w != 0 && delta > 0 && v == int32(delta) {
panic("sync: WaitGroup misuse: Add called concurrently with Wait")
}
if v > 0 || w == 0 {
return
}
if *statep != state {
panic("sync: WaitGroup misuse: Add called concurrently with Wait")
}
// Reset waiters count to 0.
*statep = 0
for ; w != 0; w-- {
// 唤醒
runtime_Semrelease(semap, false, 0)
}
}
WaitGroup.Wait()
// Wait blocks until the WaitGroup counter is zero.
func (wg *WaitGroup) Wait() {
// 获取状态和信号量
statep, semap := wg.state()
//
for {
// 查看当前的数量
state := atomic.LoadUint64(statep)
v := int32(state >> 32)
w := uint32(state)
// 为0直接返回
if v == 0 {
// Counter is 0, no need to wait.
return
}
// 记录等待
if atomic.CompareAndSwapUint64(statep, state, state+1) {
// 挂起 等调用add方法到0唤醒
runtime_Semacquire(semap)
if *statep != 0 {
panic("sync: WaitGroup is reused before previous Wait has returned")
}
if race.Enabled {
race.Enable()
race.Acquire(unsafe.Pointer(wg))
}
return
}
}
}
Once
保证在 Go 程序运行期间的某段代码只会执行一次。
type Once struct {
// 标记是否已经执行
done uint32
m Mutex
}
Once.Do()
func (o *Once) Do(f func()) {
// 如果done为0
if atomic.LoadUint32(&o.done) == 0 {
// Outlined slow-path to allow inlining of the fast-path.
o.doSlow(f)
}
}
// 保证只执行一次
func (o *Once) doSlow(f func()) {
o.m.Lock()
defer o.m.Unlock()
if o.done == 0 {
defer atomic.StoreUint32(&o.done, 1)
f()
}
}
Once.Cond()
让一系列的 Goroutine 都在满足特定条件时被唤醒。
type Cond struct {
noCopy noCopy // 编译器不允许拷贝
L Locker
notify notifyList
checker copyChecker //运行期不允许拷贝
}
type notifyList struct {
wait uint32 //正在等待的
notify uint32 //已经通知的
lock uintptr // key field of the mutex
head unsafe.Pointer //链表头
tail unsafe.Pointer //链表尾
}
Cond.Wait()
// wait方法一看 调用wait前要加锁，wait后要解锁，不然就panic啦
func (c *Cond) Wait() {
c.checker.check()
t := runtime_notifyListAdd(&c.notify) // 等待+1
c.L.Unlock() // 解锁
runtime_notifyListWait(&c.notify, t) //挂起等待
c.L.Lock() //加锁
}
Cond.Signal() 唤醒一个在wait中的（队头）
func (c *Cond) Signal() {
c.checker.check()
runtime_notifyListNotifyOne(&c.notify)
}
// 找到一个满足条件的唤醒
func notifyListNotifyOne(l *notifyList) {
t := l.notify
atomic.Store(&l.notify, t+1)
for p, s := (*sudog)(nil), l.head; s != nil; p, s = s, s.next {
if s.ticket == t {
n := s.next
if p != nil {
p.next = n
} else {
l.head = n
}
if n == nil {
l.tail = p
}
s.next = nil
readyWithTime(s, 4)
return
}
}
}
Cond.Broadcast() 唤醒全部
func (c *Cond) Broadcast() {
c.checker.check()
runtime_notifyListNotifyAll(&c.notify)
}
// 唤醒全部
func notifyListNotifyAll(l *notifyList) {
s := l.head
l.head = nil
l.tail = nil
atomic.Store(&l.notify, atomic.Load(&l.wait))
for s != nil {
next := s.next
s.next = nil
readyWithTime(s, 4)
s = next
}
}