// 普通互斥鎖
var mu sync.Mutex
mu.Lock()
// 臨界區(qū)操作
mu.Unlock()

// 標準自旋鎖（偽代碼）
type SpinLock struct {
    flag int32
}

func (s *SpinLock) Lock() {
    for !atomic.CompareAndSwapInt32(&s.flag, 0, 1) {
        // 自旋等待
    }
}

// runtime/proc.go
func sync_runtime_canSpin(i int) bool {
    // 自旋檢查邏輯
    if i >= active_spin || ncpu <= 1 || gomaxprocs <= int32(sched.npidle+sched.nmspinning)+1 {
        return false
    }
    if p := getg().m.p.ptr(); !runqempty(p) {
        return false
    }
    return true
}

ncpu > 1 // 多核處理器

i < active_spin // active_spin=4

gomaxprocs > int32(sched.npidle+sched.nmspinning)+1

runqempty(p) // P的本地隊列無等待Goroutine

func (m *Mutex) lockSlow() {
    // ...
    for {
        if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
            // 進入自旋模式
            runtime_doSpin()
            iter++
            continue
        }
        // ...
    }
}

// runtime/proc.go
func sync_runtime_doSpin() {
    procyield(active_spin_cnt) // active_spin_cnt=30
}

type Counter struct {
    mu sync.Mutex
    value int
}

func (c *Counter) Inc() {
    c.mu.Lock()
    c.value++ // 納秒級操作
    c.mu.Unlock()
}

// 基準測試結(jié)果
// 無自旋：50 ns/op
// 有自旋：35 ns/op（提升30%）

func (p *Pool) Get() *Conn {
    p.mu.Lock()
    if len(p.free) > 0 {
        conn := p.free[0]
        p.free = p.free[1:]
        p.mu.Unlock()
        return conn
    }
    p.mu.Unlock()
    return createNewConn()
}

func processBatch(data []Item) {
    var wg sync.WaitGroup
    for _, item := range data {
        wg.Add(1)
        go func(i Item) {
            defer wg.Done()
            
            // 危險！鎖內(nèi)包含IO操作
            mu.Lock()
            result := callExternalService(i) // 耗時操作
            storeResult(result)
            mu.Unlock()
        }(item)
    }
    wg.Wait()
}

func processItem(i Item) {
    result := callExternalService(i) // 移出鎖外
    
    mu.Lock()
    storeResult(result) // 僅保護寫操作
    mu.Unlock()
}

var rw sync.RWMutex

// 讀多寫少場景
func GetData() Data {
    rw.RLock()
    defer rw.RUnlock()
    return cachedData
}

type AtomicCounter struct {
    value int64
}

func (c *AtomicCounter) Inc() {
    atomic.AddInt64(&c.value, 1)
}

type SpinMutex struct {
    state int32
}

const (
    maxSpins = 50 // 高于標準Mutex
    spinBackoff = 20 // 每次PAUSE指令數(shù)
)

func (m *SpinMutex) Lock() {
    for i := 0; !atomic.CompareAndSwapInt32(&m.state, 0, 1); i++ {
        if i < maxSpins {
            runtime.Procyield(spinBackoff)
        } else {
            // 回退到休眠
            runtime.Semacquire(&m.state)
            break
        }
    }
}

// 適用場景：超高頻短鎖操作

GODEBUG=asyncpreemptoff=1 go run main.go # 禁用搶占

+----------------+          +----------------+
|   CPU Core 1   |          |   CPU Core 2   |
|   Cache Line   |          |   Cache Line   |
|  [Lock:Exclusive] --------|->[Lock:Invalid]|
+----------------+          +----------------+
        |                           |
        V                           V
+-------------------------------------------+
|                L3 Cache                   |
|                [Lock:Modified]            |
+-------------------------------------------+
        |
        V
+-------------------------------------------+
|                Main Memory                 |
+-------------------------------------------+

// x86實現(xiàn)
procyield:
    MOVL    cycles+0(FP), AX
again:
    PAUSE
    SUBL    $1, AX
    JNZ     again
    RET

// 檢查等待時間
start := time.Now()
mu.Lock()
waitTime := time.Since(start)
if waitTime > 1*time.Millisecond {
    log.Warn("鎖競爭激烈")
}

go test -bench=. -benchtime=10s -cpuprofile=cpu.out
go tool pprof cpu.out