How to create a read-only map in golang

Golang is a strongly typed programming language with some unique features. One of them is map, which is a very practical data structure in Golang language. However, although map is powerful, in some application scenarios, we actually only need to perform "read-only" operations on map. At this time, you need to make some restrictions on the map to make it a "read-only" map that can only perform read operations.

Why do we need 'read-only' operation?

Actually, if you have multiple goroutines reading and writing map concurrently, some unpredictable results may occur. In this case, map is not safe and may cause data errors or even crash. Therefore, in order to ensure the safety and stability of the program, we may need to make the map read-only to prevent additional changes.

How to create a read-only map?

In golang, we can use sync.Map to create a read-only map. sync.Map is a concurrently safe map implementation. Its read and write operations are atomic, so it is thread-safe when multiple goroutines read and write concurrently. The difference between sync.Map and ordinary map is that its key and value types are both interface{}, which allows it to support any type of data.

Code example:

package main

import (
    "sync"
    "fmt"
)

func main() {
    readOnlyMap := readOnlyMap()
    readOnlyMap.LoadOrStore("foo", "bar")

    fmt.Println(readOnlyMap.Load("foo"))
    readOnlyMap.Delete("foo")
    fmt.Println(readOnlyMap.Load("foo"))
}

func readOnlyMap() *sync.Map {
    m := &sync.Map{}
    return m
}

In the above example, we can see that there is a function called readOnlyMap(), which returns a pointer of type *sync.Map. We use this function in the main function to obtain a read-only sync.Map object.

We can use the Load() function to read the value in the read-only map, and Delete() to delete a key-value pair. However, we cannot use the Store() function to write a new key-value pair.

How to use read-only map in goroutine?

A major feature of the go language is its support for concurrency. If we share a read-only map between multiple goroutines, then we must ensure that it can be safely read in a concurrent environment. For this, we can use sync.RWMutex to lock. RWMutex is a read-write lock in the go language. We can use it to perform mutual exclusion of read and write operations.

Code Example:

package main

import (
    "sync"
    "fmt"
)

func main() {
    var wg sync.WaitGroup
    readOnlyMap := readOnlyMap()
    readOnlyMap.LoadOrStore("foo", "bar")

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            readOnlyMapOperation(readOnlyMap, "foo")
        }()
    }

    wg.Wait()
}

func readOnlyMapOperation(m *sync.Map, key interface{}) interface{} {
    m.RLock()
    defer m.RUnlock()

    return m.Load(key)
}

func readOnlyMap() *sync.Map {
    m := &sync.Map{}
    return m
}

In the above example, we use a read-only sync.Map object to read the value of the "foo" key. We created 100 goroutines, and each goroutine used the readOnlyMapOperation() function to read the value in the sync.Map object. The sync.RWMutex read-write lock is used in the readOnlyMapOperation() function to ensure that read-only operations are thread-safe under concurrent conditions.

Summary

Read-only map is a very practical data structure in the Go language. It can provide safe and efficient support when multiple goroutines read shared data concurrently. In actual applications, we need to understand the RWMutex read-write lock mechanism in the code and make correct restrictions on the map as needed to achieve optimal performance and security.

The above is the detailed content of How to create a read-only map in golang. For more information, please follow other related articles on the PHP Chinese website!