Master the sync.RWMutex function in the Go language documentation to implement read-write locks

To master the sync.RWMutex function in the Go language document to implement read-write locks, specific code examples are required

Read-write locks are a thread synchronization mechanism that allows multiple Threads can read shared resources at the same time, but only one thread is allowed to write to shared resources. This mechanism can improve program concurrency and performance. The sync package in the Go language provides the sync.RWMutex function to implement the read-write lock function.

sync.RWMutex is a read-write lock structure. It has two methods: RLock() and RUnlock() for reading shared resources, and Lock() and Unlock() for writing shared resources. .

The following is a specific code example that demonstrates how to use the sync.RWMutex function to implement a read-write lock:

package main

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

type Data struct {
    value int
    mutex sync.RWMutex
}

func (d *Data) Read() {
    d.mutex.RLock()
    defer d.mutex.RUnlock()
    fmt.Printf("Read value: %d
", d.value)
}

func (d *Data) Write(value int) {
    d.mutex.Lock()
    defer d.mutex.Unlock()
    d.value = value
    fmt.Printf("Write value: %d
", value)
}

func main() {
    data := &Data{}

    // 启动多个读取线程
    for i := 0; i < 3; i++ {
        go func() {
            for {
                data.Read()
                time.Sleep(time.Millisecond * 500)
            }
        }()
    }

    // 启动一个写入线程
    go func() {
        for i := 0; i < 5; i++ {
            data.Write(i + 1)
            time.Sleep(time.Second)
        }
    }()

    // 等待一段时间观察输出结果
    time.Sleep(time.Second * 10)
}

In the above code, we create an integer value and an The structure Data of the read-write lock. The Read() function is used to read values ​​and output them, and the Write() function is used to write new values. In the main() function, we start three reading threads and one writing thread, and use the time.Sleep() function to let the program run for a period of time.

Run the above code, we will see that the reading thread and the writing thread execute alternately. The reading thread uses RLock() to obtain the read lock by calling the Read() function, so that multiple reading threads can read the value at the same time. The writing thread uses Lock() to obtain the write lock by calling the Write() function, so that only one writing thread can write new values. The final output result is that the reading thread reads the value written by the writing thread.

Through this code example, we can clearly understand how to use the sync.RWMutex function to implement read-write locks. Read-write locks can improve program concurrency and performance, and are especially suitable for scenarios where there is more reading and less writing. When multiple threads need to read shared resources without writing operations, read-write locks can greatly improve the efficiency of the program.

The above is the detailed content of Master the sync.RWMutex function in the Go language documentation to implement read-write locks. For more information, please follow other related articles on the PHP Chinese website!