Study Golang's lock implementation

Exploring the implementation mechanism of Golang lock

Introduction:

In concurrent programming, lock (Lock) is a commonly used synchronization mechanism. To protect access to shared resources. As a programming language with high concurrency performance and concise syntax, Golang provides a wealth of lock mechanisms, including mutex (Mutex), read-write lock (RWMutex), etc. This article will delve into the implementation mechanism of Golang locks and demonstrate it through specific code examples.

1. The implementation mechanism of mutex lock (Mutex)

1. Lock method implementation:

The implementation mechanism of mutex lock is mainly through three important Components: wait queues, status flags, and atomic operations. When a thread tries to acquire a mutex lock, it will first check the status flag. If the status flag is locked, it will add itself to the waiting queue and spin to wait. If the status flag is unlocked, try to use atomic operations to acquire the lock and set the status flag to locked. The following is a specific code example of a mutex lock:

type Mutex struct {
    waiting   int32 // 等待队列，记录等待获取锁的goroutine数量
    isLocked  int32 // 锁的状态标志，0代表未锁住，1代表已锁住
}

func (m *Mutex) Lock() {
    for !atomic.CompareAndSwapInt32(&m.isLocked, 0, 1) { // 自旋等待获取锁
        runtime.Gosched()
    }
}

func (m *Mutex) Unlock() {
    atomic.StoreInt32(&m.isLocked, 0) // 释放锁，将状态标志设置为未锁住
}

2. Atomic operation implementation:

The above code uses the CompareAndSwapInt32 and StoreInt32 functions in the atomic package to implement atomic operations . The CompareAndSwapInt32 function is used for comparison and exchange operations. If the status flag of the lock is unlocked, it is set to locked and returns true; if the status flag of the lock is locked, it returns false. The StoreInt32 function is used to atomically set the status flag to unlocked. These atomic operations can effectively avoid the occurrence of race conditions and ensure the correctness of the lock.

2. The implementation mechanism of read-write lock (RWMutex)

1. The implementation mechanism of write lock:

The read-write lock is a special kind of lock mechanism, which allows multiple goroutines to read shared resources at the same time, but only allows one goroutine to write to shared resources. The implementation mechanism of write lock is similar to that of mutex lock, but there are some differences. The following is a specific code example of a write lock:

type RWMutex struct {
    writerSem uint32    // 写入信号量，用于限制只能有一个goroutine写入
    readerSem uint32    // 读取信号量，用于限制多个goroutine同时读取
    readerCount int32   // 读取计数，记录当前同时读取的goroutine数量
    readerWait  int32   // 当前等待读取的goroutine数量
}

func (rw *RWMutex) Lock() {
    rw.lockWhile(func() {atomic.LoadUint32(&rw.readerSem) != 0 || atomic.LoadUint32(&rw.writerSem) != 0})
    atomic.AddUint32(&rw.writerSem, 1) // 获取写锁，递增写入信号量
}

func (rw *RWMutex) Unlock() {
    atomic.AddUint32(&rw.writerSem, ^uint32(0)) // 释放写锁，递减写入信号量
    rw.unlockWhile(func() {atomic.LoadInt32(&rw.readerCount) != 0}) // 释放读锁，根据读取计数判断是否需要唤醒等待读取的goroutine
}

2. Implementation mechanism of read lock:

The implementation mechanism of read lock is mainly through incrementing the read semaphore and read count To achieve this, when a goroutine acquires a read lock, it will first check whether the write semaphore is zero and there are no other goroutines waiting to write. If so, it will increment the read count and acquire the read lock; otherwise, it will add itself to the waiting queue. Perform spin wait. The following is a specific code example of a read lock:

func (rw *RWMutex) RLock() {
    rw.lockWhile(func() {atomic.LoadUint32(&rw.writerSem) != 0}) // 当有 goroutine 持有写锁时，自旋等待
    atomic.AddInt32(&rw.readerCount, 1) // 递增读取计数
}

func (rw *RWMutex) RUnlock() {
    atomic.AddInt32(&rw.readerCount, -1) // 递减读取计数
    rw.unlockWhile(func() {atomic.LoadInt32(&rw.readerCount) != 0}) // 根据读取计数判断是否需要唤醒等待读取的goroutine
}

3. Wake up the waiting goroutine:

In the implementation of the read-write lock, there is an operation to wake up the waiting goroutine. It is implemented through two auxiliary functions: lockWhile and unlockWhile. The lockWhile function is used for spin waiting. When the given condition is true, the goroutine will be blocked until the condition is met; the unlockWhile function is used to wake up the waiting goroutine according to the given condition so that it can compete for the lock. This ensures that goroutines waiting for locks can be awakened in time and improves concurrency performance.

Summary:

In this article, we conducted an in-depth exploration of the lock implementation mechanism in Golang and demonstrated it through specific code examples. Mutex locks are implemented through waiting queues and status flags to ensure that only one goroutine can hold the lock; while read-write locks are implemented through write semaphores, read semaphores and read counts, allowing multiple goroutines to read and write at the same time. Only one goroutine is allowed to write. These lock mechanisms ensure safe access to shared resources and improve the performance of concurrent programs through atomic operations and conditional waiting.

The above is the detailed content of Study Golang's lock implementation. For more information, please follow other related articles on the PHP Chinese website!