Golang mutex underlying implementation

Golang is an efficient and concise programming language, and its good performance and ease of use are reflected in the application of concurrent programming. In concurrent programming, Mutex is a very common synchronization mechanism. It can ensure mutually exclusive access to shared resources in a multi-threaded environment while avoiding race conditions (that is, unpredictable results when multiple threads access shared resources at the same time). . This article will introduce the underlying implementation principle of Mutex.

1. Definition of Mutex

In Golang, Mutex is a synchronization mechanism used to protect mutually exclusive access to shared resources. It contains two methods: Lock() and Unlock(), which are used to lock and unlock Mutex respectively. When a thread acquires the Mutex's lock, other threads will be blocked until the lock is released.

2. The underlying implementation of Mutex

In Golang, the underlying implementation of Mutex mainly relies on a structure called sync.Mutex. The implementation of Mutex is implemented through CAS operation (Compare-And-Swap), which relies on the atomic operation of the underlying hardware.

The Mutex structure is defined as follows:

type Mutex struct {
    state int32
    sema  *uint32 // 信号量
}

const (
    mutexLocked = 1 << iota // mutex is locked
)

func (m *Mutex) Lock() {
    // Fast path: 这里如果加锁成功，就直接返回
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        return
    }
    // Slow path : 防止出现busy spinning，将当前协程加入等待队列，然后调用runtime.semacquire继续sleep。
    sema := m.sema
    if sema == nil {
        sema = new(uint32)
        m.sema = sema
    }
    runtime_Semacquire(sema)
}

func (m *Mutex) Unlock() {
    // Fast path: 这里如果释放锁成功，就直接返回
    if atomic.CompareAndSwapInt32(&m.state, mutexLocked, 0) {
        return
    }
    // Slow path: 如果锁还被持有，则调用sync.runtime_Semrelease继续唤醒协程。
    sema := m.sema
    if sema == nil {
        panic("sync: unlock of unlocked mutex")
    }
    runtime_Semrelease(sema, false, 1)
}

The Mutex structure contains two fields, a state and a semaphore sema. Among them, state indicates the status of the lock, mutexLocked indicates that it is locked, and other values ​​indicate that it is not locked. sema is used to coordinate goroutines waiting for locks.

In the Mutex.Lock() method, if the current Mutex is not locked, use the CompareAndSwapInt32 atomic operation to change the state from 0 to mutexLocked, and return directly after success; otherwise, let the current goroutine join the waiting queue, And call the runtime.semacquire() method to wake it up. In the Mutex.Unlock() method, if the current Mutex is locked, use the CompareAndSwapInt32 atomic operation to change the state from mutexLocked to 0, and return directly after success; otherwise, an exception is thrown, indicating that the current Mutex is not locked.

There are fast paths and slow paths in both the Mutex.Lock() and Mutex.Unlock() methods. The fast path means that when the lock status is not occupied, the lock can be quickly obtained or the lock can be quickly released through CAS. The slow path means that when the lock status is occupied, the current goroutine needs to be added to the waiting queue and the sema.acquire() method is called to sleep it or wake up other goroutines in the waiting queue.

3. Misunderstandings in the use of Mutex

In Golang, Mutex is a very commonly used synchronization mechanism, but during use, there are some common misunderstandings that we need to avoid.

1. The goroutine that calls the Unlock() method must be the goroutine that holds the Mutex

If a goroutine tries to release a Mutex that it does not hold, the program will throw panic. Mutex locks are to ensure mutually exclusive access to shared resources. If any goroutine can release the lock, then its mutual exclusivity cannot be guaranteed.

2. Don’t copy Mutex

Mutex lock is a pointer type. If you need to copy the lock variable, you should use pointer copy. Otherwise, it will result in two unrelated Mutex instances sharing the same state, which may lead to unexpected behavior.

3. Try to avoid free competition for locks

In concurrent programming, free competition for locks means that before one goroutine releases the lock, another goroutine will continue to Try to acquire the lock instead of waiting in the waiting queue. This will lead to a waste of CPU resources, and this situation should be avoided as much as possible.

In short, locks are a powerful tool for protecting shared resources and play a very important role in concurrent programming. Through this article, we understand the underlying implementation principle of Mutex, as well as some misunderstandings that need to be paid attention to when using Mutex. In actual development, we should make full use of the advantages of Mutex to avoid various problems that may arise in concurrent programming.

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