How to solve the problem of concurrent resource competition in Go language?

How to solve the problem of concurrent resource competition in Go language?

In concurrent programming, resource competition is a common problem, which refers to the uncertain behavior caused by multiple goroutines accessing, reading and writing shared resources at the same time. The Go language provides some mechanisms to solve the problem of concurrent resource competition. This article will introduce some common methods and give specific code examples.

1. Mutex lock (Mutex)

Mutex lock is one of the most commonly used methods to solve resource competition. It can ensure that only one goroutine can access shared resources at the same time, and other goroutines need to wait. The sync package in the Go language provides the Mutex type, which can be locked and unlocked by calling the Lock() and Unlock() methods.

The following is a sample code:

package main

import (
    "fmt"
    "sync"
    "time"
)

var count int
var mutex sync.Mutex

func increment() {
    mutex.Lock()
    defer mutex.Unlock()
    time.Sleep(1 * time.Second) // 模拟耗时操作
    count++
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            increment()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println("Count:", count)
}

In the above code, multiple goroutines call the increment() function concurrently to increase the value of count. In order to ensure that only one goroutine can access count at the same time, we use a mutex lock for lock protection. By using the Lock() and Unlock() methods of the Mutex type, we ensure that the result when printing the count at the end is correct.

2. Read-write mutex (RWMutex)

The mutex may have performance issues in some scenarios because it only allows one goroutine to access shared resources. If multiple goroutines only read shared resources without writing during concurrent reading, you can use a read-write mutex (RWMutex). RWMutex allows multiple goroutines to obtain permission to read shared resources at the same time, but only allows one goroutine to obtain permission to write shared resources.

The following is a sample code:

package main

import (
    "fmt"
    "sync"
    "time"
)

var count int
var rwMutex sync.RWMutex

func read() {
    rwMutex.RLock()
    defer rwMutex.RUnlock()
    time.Sleep(1 * time.Second) // 模拟耗时操作
    fmt.Println("Read:", count)
}

func write() {
    rwMutex.Lock()
    defer rwMutex.Unlock()
    time.Sleep(1 * time.Second) // 模拟耗时操作
    count++
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            read()
            wg.Done()
        }()
    }
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            write()
            wg.Done()
        }()
    }
    wg.Wait()
}

In the above code, we define a global count variable and use rwMutex of RWMutex type for lock protection. The read() function adds read locks by calling the RLock() and RUnlock() methods to implement concurrent reading of shared resources; the write() function adds write locks by calling the Lock() and Unlock() methods to implement Concurrent write operations to shared resources.

By using mutex locks and read-write mutex locks, we can effectively solve the problem of concurrent resource competition and ensure correct access to shared resources between multiple goroutines. In actual development, we need to choose an appropriate locking mechanism based on specific scenarios and needs. At the same time, try to avoid too many locking operations to avoid affecting the performance of the program.

To sum up, the Go language provides mutex locks and read-write mutex locks to solve the problem of concurrent resource competition. The use of mutex locks can achieve exclusive access to shared resources, while the use of read-write mutex locks can allow concurrent read operations while ensuring data consistency. Correct use of the locking mechanism can ensure program correctness and performance.

The above is the detailed content of How to solve the problem of concurrent resource competition in Go language?. For more information, please follow other related articles on the PHP Chinese website!