2019-03-08 微信讨论

type Store struct {
    a string
    b string

    sync.RWMutex
}

func (s *Store) GetA() string {
    fmt.Println("get a")
    s.RLock()
    fmt.Println("get a2")
    defer s.RUnlock()

    return s.a
}

func (s *Store) GetAB() (string, string) {
    fmt.Println("get ab")
    s.RLock()
    fmt.Println("get ab2")
    defer s.RUnlock()

    return s.GetA(), s.b
}

func (s *Store) Write(a, b string) {
    fmt.Println("write")
    s.Lock()
    defer s.Unlock()
    fmt.Println("write2")

    s.a = a
    s.b = b
}

func main() {
    store := Store{}
    wg := sync.WaitGroup{}
    wg.Add(2)
    go func() {
        defer wg.Done()
        for i := 1; i < 10000; i += 1 {
            fmt.Println("main write ", i)
            store.Write("111", "1111")
        }
    }()
    go func() {
        defer wg.Done()
        for i := 1; i < 10000; i += 1 {
            fmt.Println("main get ab", i)
            store.GetAB()
        }
    }()
    wg.Wait()
}

main get ab 12  //main函数读取ab
get ab          //进入 s.GetAB 函数
main write  1   //main 函数写数据
write           //进入 s.Write 函数
write2          //获取写锁
main write  2
....            //写锁一直抢占
....
main write  13  //main 函数写数据
write           //进入 s.Write 函数
write2          //获取写锁
main write  14  
write
write2
get ab2         //之前 get ab 12 才获得读锁
get a           //进入 GetA 
get a2          //获取读锁
main get ab 13  //main函数 get ab
get ab          //进入 s.GetAB 函数
get ab2         //获取读锁
main write  15  //注意⚠️ 这个时候写数据开始了
write           //进入 Write 函数，后面尝试获取写锁
get a           //这个时候 GetAB 进入了 GetA，尝试获取读锁
fatal error: all goroutines are asleep - deadlock!  //出现了死锁

    GetAB       |            GetA               |                Write
                |                               |
r0 占用读锁      |                               |
                |                               |    w0 尝试获取写锁 等待r0释放读锁
                |   r1 尝试获取读锁，排在w0后面     |

type RWMutex struct {
    w           Mutex  // 用来保证同一时间只有一个写锁能够抢到锁
    writerSem   uint32 // 写锁信号量，在读锁全部解锁时通知阻塞的写锁
    readerSem   uint32 // 读锁信号量，在写锁解锁时通知阻塞的读操作
    readerCount int32  // 等待、已上锁的读锁数量
    readerWait  int32  // 写锁获得锁前，已经上锁的读锁数量
}

func (rw *RWMutex) RLock() {
    ...
    if atomic.AddInt32(&rw.readerCount, 1) < 0 {
        // A writer is pending, wait for it.
        runtime_SemacquireMutex(&rw.readerSem, false)
    }
    ...
}

func (rw *RWMutex) RUnlock() {
    ...
    if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 { 
        if r+1 == 0 || r+1 == -rwmutexMaxReaders {
            race.Enable()
            throw("sync: RUnlock of unlocked RWMutex")
        }

        // A writer is pending.
        if atomic.AddInt32(&rw.readerWait, -1) == 0 {
            // The last reader unblocks the writer.
            runtime_Semrelease(&rw.writerSem, false)
        }
    }
    ...
}

func (rw *RWMutex) Lock() {
    ...
    // First, resolve competition with other writers.
    rw.w.Lock()
    // Announce to readers there is a pending writer.
    r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
    // Wait for active readers.
    if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
        runtime_SemacquireMutex(&rw.writerSem, false)
    }
    ...
}

func (rw *RWMutex) Unlock() {
    ...
    // Announce to readers there is no active writer.
    r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
    if r >= rwmutexMaxReaders {
        race.Enable()
        throw("sync: Unlock of unlocked RWMutex")
    }
    // Unblock blocked readers, if any.
    for i := 0; i < int(r); i++ {
        runtime_Semrelease(&rw.readerSem, false)
    }
    // Allow other writers to proceed.
    rw.w.Unlock()
    ...
}