GO中公平锁和非公平锁的具体使用

type Mutex struct {
    state int32
    sema  uint32
}

func (m *Mutex) Lock() {
    // 快速路径：尝试直接获取锁
    if atomic.CompareAndSwapInt32(&m.state, 0, 1) {
        return
    }
    // 慢速路径：获取不到锁时，调用lockSlow方法
    m.lockSlow()
}

func (m *Mutex) Unlock() {
    // 快速路径：尝试直接释放锁
    if atomic.CompareAndSwapInt32(&m.state, 1, 0) {
        return
    }
    // 慢速路径：释放锁时，调用unlockSlow方法
    m.unlockSlow()
}

type FairMutex struct {
    mu       sync.Mutex
    cond     *sync.Cond
    waiting  []chan struct{}
}

func NewFairMutex() *FairMutex {
    fm := &FairMutex{}
    fm.cond = sync.NewCond(&fm.mu)
    return fm
}

func (fm *FairMutex) Lock() {
    fm.mu.Lock()
    defer fm.mu.Unlock()

    ch := make(chan struct{})
    fm.waiting = append(fm.waiting, ch)

    if len(fm.waiting) > 1 {
        <-ch
    }
}

func (fm *FairMutex) Unlock() {
    fm.mu.Lock()
    defer fm.mu.Unlock()

    if len(fm.waiting) > 0 {
        fm.waiting = fm.waiting[1:]
        if len(fm.waiting) > 0 {
            close(fm.waiting[0])
        }
    }
}