About Mutex in Go concurrent programming

                                                                                                                                             

The following is introduced to you by the golangtutorial column Go Mutex for concurrent programming, I hope it will be helpful to friends in need!

Friendly reminder: This article takes about 5 minutes and 45 seconds to read. Please give me more advice on any shortcomings. Thank you for reading.

Concurrent access problems will appear in the design of our more common large-scale projects. Concurrency is to solve the accuracy of data and ensure that the data in the same critical section can only be operated by one thread. It is used in daily life There are also many concurrent scenarios:

• Counter: The counter result is inaccurate;
• Second Kill System: Due to the large number of visits at the same time , resulting in oversold;
• User account abnormality: account overdraft caused by payment at the same time;
• buffer data abnormality: caused by updating buffer The data is messy.

The above are all problems of data accuracy caused by concurrency. The decisive solution is to use mutex lock, which is the Mutex concurrency primitive to be described in today's concurrent programming. .

Implementation mechanism

Mutex lock Mutex is a concurrency control mechanism established to avoid concurrency competition, in which there is the concept of "critical section".

In the process of concurrent programming, if some resources or variables in the program will be accessed or modified concurrently, in order to avoid data inaccuracies caused by concurrent access, this part of the program needs to be protected first, and then operated , remove the protection after the operation is completed, this part of the protected program is called critical section.

Use a mutex lock to limit the critical section to be held by only one thread at the same time. If the critical section is held by one thread at this time, then other threads want to enter this When the critical section is reached, it will fail or wait for the lock to be released. The thread holding this critical section will exit, and other threads will have the opportunity to obtain this critical section.

go mutex critical section diagram

Mutex is the most widely used synchronization primitive in the Go language, also known as concurrency primitive,Solution The purpose is to concurrently read and write shared resources to avoid data race problems.

Basic use

Mutex provides two methods, Lock and Unlock: to enter the critical section, use the Lock method to lock, and to exit the critical section, use The Unlock method releases the lock.

type Locker interface {
    Lock()
    Unlock()}func(m *Mutex)Lock()func(m *Mutex)Unlock()

When a goroutine calls the Lock method to acquire the lock, other goroutines will block on the Lock call until the goroutine currently acquiring the lock releases the lock.

The following is an example of a counter, which is performed by 100 goroutines to accumulate the counter, and the final output result is:

package mainimport (
    "fmt"
    "sync")func main() {
    var mu sync.Mutex
    countNum := 0

    // 确认辅助变量是否都执行完成
    var wg sync.WaitGroup    // wg 添加数目要和 创建的协程数量保持一致
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go func() {
            defer wg.Done()
            for j := 0; j < 1000; j++ {
                mu.Lock()
                countNum++
                mu.Unlock()
            }
        }()
    }
    wg.Wait()
    fmt.Printf("countNum: %d", countNum)}

Actual use

Many times Mutex is not used alone, but is used nested in a Struct as part of the structure. If the embedded struct has multiple fields, we generally put the Mutex in the field to be controlled. above, and then use spaces to separate the fields.

You can even encapsulate the logic of acquiring locks, releasing locks, and counting by one into a method.

package mainimport (
    "fmt"
    "sync")// 线程安全的计数器type Counter struct {
    CounterType int
    Name        string

    mu    sync.Mutex
    count uint64}// 加一方法func (c *Counter) Incr() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++}// 取数值方法 线程也需要受保护func (c *Counter) Count() uint64 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count}func main() {
    // 定义一个计数器
    var counter Counter    var wg sync.WaitGroup
    wg.Add(100)

    for i := 0; i < 100; i++ {
        go func() {
            defer wg.Done()
            for j := 0; j < 1000; j++ {
                counter.Incr()
            }
        }()
    }
    wg.Wait()

    fmt.Printf("%d\n", counter.Count())}

Thinking Questions

Q: You already know that if Mutex has been locked by a goroutine, other waiting goroutines can only wait forever. . So, after the lock is released, which of the waiting goroutines will get the Mutex first?

A: FIFO, first come first served strategy. In Go's goroutine scheduling, a queue is maintained to ensure the running of goroutine. When the goroutine that acquires the lock completes the operation of the critical section, it will be released. Lock, the goroutine ranked first in the queue will get the lock to operate the critical section.                                                                                                                    

The above is the detailed content of About Mutex in Go concurrent programming. For more information, please follow other related articles on the PHP Chinese website!