Familiar with the lock and mutex mechanisms in Go language

Go language is a very popular programming language, especially in concurrent programming. And when we are dealing with concurrent programming, locks and mutual exclusion mechanisms are inevitable. This article will introduce the lock and mutual exclusion mechanism in Go language.

1. Mutex lock

Mutex lock is the most basic locking mechanism and is also widely used in the Go language. In some cases, multiple goroutines may access shared variables at the same time. In this case, we need to use a mutex lock to restrict only one goroutine from accessing shared variables at the same time.

In the Go language, the use of mutex locks is very simple. We only need to add mutex.Lock() and mutex.Unlock before and after the code segment that needs to be protected. (), where mutex is a variable of type sync.Mutex.

In the following sample code, we simulated multiple goroutines accessing a shared variable at the same time. At this time, the mutex lock can ensure that only one goroutine can modify the variable value at the same time.

package main

import (
    "fmt"
    "sync"
)

var count int
var mutex sync.Mutex

func main() {
    for i := 0; i < 10; i++ {
        go increment()
    }
    fmt.Scanln()
}

func increment() {
    for i := 0; i < 10000; i++ {
        mutex.Lock()
        count++
        mutex.Unlock()
    }
}

2. Read-write lock

In the above example, we use a mutex lock to restrict access to shared variables. However, in some cases, read operations are more frequent than write operations. In this case, using a mutex lock will lead to poor read performance because the mutex lock will block other goroutine read and write operations.

In order to solve this problem, the Go language provides a special lock mechanism called read-write lock. Read-write locks can support multiple goroutines for read operations at the same time, but when write operations are in progress, all read and write operations must be excluded.

In the Go language, the use of read-write locks is also very simple. We only need to add rwlock.RLock() and rwlock.RUnlock() before and after the code segment that needs to be protected for read operations, and rwlock.Lock( ) and rwlock.Unlock() are used for write operations. Among them, rwlock is a variable of type sync.RWMutex.

The following example demonstrates the situation where multiple goroutines read a shared variable at the same time. We use read-write locks to ensure efficient read operations.

package main

import (
    "fmt"
    "sync"
)

var count int
var rwlock sync.RWMutex

func main() {
    for i := 0; i < 10; i++ {
        go read()
    }
    fmt.Scanln()
}

func read() {
    for i := 0; i < 10000; i++ {
        rwlock.RLock()
        fmt.Println(count)
        rwlock.RUnlock()
    }
}

3. Atomic operations

In some cases, we only need to perform simple addition and subtraction operations, which can be achieved through atomic operations. Atomic operations can ensure that the execution order of these simple operations in multiple goroutines is stable, thus avoiding race conditions.

In the Go language, atomic operations can be implemented through some functions in the sync/atomic package. For example, atomic.AddInt32(&count, 1) This function can add 1 to the count variable through atomic addition.

The following example demonstrates how to use atomic operations to safely increment the value of a variable in multiple goroutines.

package main

import (
    "fmt"
    "sync/atomic"
)

var count int32

func main() {
    for i := 0; i < 10; i++ {
        go increment()
    }
    fmt.Scanln()
}

func increment() {
    for i := 0; i < 10000; i++ {
        atomic.AddInt32(&count, 1)
    }
}

To sum up, the Go language provides a variety of locks and mutual exclusion mechanisms to protect access to shared variables, and also supports atomic operations to avoid race conditions. It is very important for Go language developers to be familiar with the use of these mechanisms.

The above is the detailed content of Familiar with the lock and mutex mechanisms in Go language. For more information, please follow other related articles on the PHP Chinese website!