Built-in locks and mutexes in Go language

Built-in locks and mutexes in Go language

With the popularity of multi-core processors, multi-threaded programming has become an indispensable part of application development. In multi-threaded programming, locks are an important mechanism used to control concurrent access to shared resources. The Go language provides a wealth of locking mechanisms, the most commonly used of which are built-in locks and mutexes.

Bring your own lock

Bring your own lock is a lock mechanism in the Go language, which is lightweight, easy to use and high-performance. The built-in lock is a variable with competition conditions. That is, when accessing shared resources concurrently, if multiple threads access the variable at the same time, a competition condition will occur. In this case, synchronization is required to avoid inconsistent results.

In the Go language, synchronization operations can be easily performed using the built-in lock. The built-in lock has two important methods, Lock() and Unlock(). The Lock() method is used to acquire the lock. If the lock is already occupied by other threads, the calling thread will enter the blocking state and wait for the lock to be released; Unlock() Method is used to release the lock.

Example of using built-in lock:

var mu sync.Mutex  // 定义一个锁变量
var count int

func main() {
    for i := 0; i < 1000; i++ {
        go add()  // 启动1000个线程，对count进行加1操作
    }
    time.Sleep(time.Second)  // 等待所有线程执行完成
    fmt.Println(count)  // 打印最终结果
}

func add() {
    mu.Lock()  // 获取锁
    count++  // 对共享变量进行操作
    mu.Unlock()  // 释放锁
}

In the above code, a global variable count is used as a shared resource, and it is incremented by 1 by starting 1000 threads. In order to ensure that concurrent access to the count variable will not cause race conditions, a built-in lock is used for synchronization. In the add() function, first call the mu.Lock() method to acquire the lock, operate the shared resource, and then release the lock through the mu.Unlock() method. This ensures that the operation on the count variable is atomic and avoids race conditions.

Mutex

Mutex is another locking mechanism in Go language, which is also used to protect shared resources. Mutexes are similar to built-in locks and can be used to prevent race conditions from occurring, but in comparison, mutexes can lock and unlock operations on more fine-grained blocks of code.

The use of mutex is similar to its own lock. In the Go language, the type of mutex is sync.Mutex, and the prototype is as follows:

type Mutex struct {
    // 包含Mutex的内部结构
}

func (m *Mutex) Lock() {
    // 加锁操作
}

func (m *Mutex) Unlock() {
    // 解锁操作
}

When using a mutex, you also need to add code that requires synchronization between the Lock() and Unlock() methods. blocks to ensure the correctness of shared resources.

Example of using a mutex:

var mu sync.Mutex  // 定义一个互斥量
var count int

func main() {
    for i := 0; i < 1000; i++ {
        go add()  // 启动1000个线程，对count进行加1操作
    }
    time.Sleep(time.Second)  // 等待所有线程执行完成
    fmt.Println(count)  // 打印最终结果
}

func add() {
    mu.Lock()  // 获取锁
    count++  // 对共享变量进行操作
    mu.Unlock()  // 释放锁
}

Similar to the use of built-in locks, a mutex is used in the above code to synchronize access to the shared resource count.

Summary

Built-in locks and mutexes are common synchronization mechanisms in the Go language, used to protect shared resources from concurrent modification. The built-in lock is suitable for locking and unlocking operations on the entire code block, while the mutex can perform locking and unlocking operations on more fine-grained code blocks. In actual development, the appropriate lock mechanism should be selected according to specific needs to ensure the reliability and concurrency of the program.

The above is the detailed content of Built-in locks and mutexes in Go language. For more information, please follow other related articles on the PHP Chinese website!