Ask me anything
Ithy Logo
Sign in to save

Go 的 sync.Map 不同版本 API 详解

Client-Side APIs

概述

在 Go 语言中，sync.Map 是一个高性能、并发安全的映射类型，旨在解决标准 Go 映射在并发场景下的局限性。它特别适用于读多写少的场景，提供了一组专为并发设计的 API，简化了在多线程环境中对共享数据的管理。

sync.Map 的发展历程与 API 变化

Go 1.9 及更高版本

自 Go 1.9 版本引入 sync.Map 以来，其 API 主要包括以下方法：

  • Store: 用于存储一个键值对。 
    func (m *Map) Store(key, value interface{})

    示例：

    m.Store("username", "alice")
  • Load: 用于加载指定键的值，如果键不存在，则返回 nil 和 false。 
    func (m *Map) Load(key interface{}) (value interface{}, ok bool)

    示例：

    value, exists := m.Load("username")
if exists {
    fmt.Println("Username:", value)
}
  • LoadOrStore: 尝试加载指定键的值，如果键不存在，则存储并返回新值。 
    func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)

    示例：

    actual, loaded := m.LoadOrStore("session", newSession())
if loaded {
    fmt.Println("Session already exists:", actual)
} else {
    fmt.Println("New session created.")
}
  • Delete: 删除指定键的值。 
    func (m *Map) Delete(key interface{})

    示例：

    m.Delete("username")
  • Range: 遍历所有键值对，调用提供的函数 f，直到函数返回 false 或者遍历完所有项。 
    func (m *Map) Range(f func(key, value interface{}) bool)

    示例：

    m.Range(func(key, value interface{}) bool {
    fmt.Println(key, value)
    return true
})

Go 1.20 及更高版本

为了进一步增强 sync.Map 的功能性和并发控制能力，Go 1.20 引入了以下新增方法：

  • CompareAndDelete: 如果指定键的当前值与提供的旧值相等，则删除该键值对。 
    func (m *Map) CompareAndDelete(key, old interface{}) bool

    示例：

    if m.CompareAndDelete("token", "abc123") {
    fmt.Println("Token successfully deleted.")
} else {
    fmt.Println("Token deletion failed.")
}
  • CompareAndSwap: 如果指定键的当前值与提供的旧值相等，则将其替换为新值。 
    func (m *Map) CompareAndSwap(key, old, new interface{}) bool

    示例：

    if m.CompareAndSwap("count", 1, 2) {
    fmt.Println("Count updated to 2.")
} else {
    fmt.Println("Count update failed.")
}

这些新增方法增强了对 sync.Map 中数据的一致性和原子性操作，尤其在需要精细控制并发修改时尤为有用。

主要方法详解

Store

Store 方法用于在 sync.Map 中存储或更新一个键值对。如果键已存在，则会更新其对应的值；否则，会新增一个键值对。

m.Store("key", "value")

Load

Load 方法用于检索指定键的值。如果键存在，则返回其值和 true；否则，返回 nil 和 false。

value, ok := m.Load("key")
if ok {
    fmt.Println("Value:", value)
} else {
    fmt.Println("Key not found.")
}

LoadOrStore

LoadOrStore 方法尝试加载指定键的值。如果键存在，则返回其当前值和 true；如果键不存在，则存储并返回新的值和 false。

actual, loaded := m.LoadOrStore("key", "newValue")
if loaded {
    fmt.Println("Key already exists with value:", actual)
} else {
    fmt.Println("Key stored with new value:", actual)
}

Delete

Delete 方法用于删除指定键的值。如果键存在，则删除该键值对；否则，无任何操作。

m.Delete("key")

Range

Range 方法用于遍历 sync.Map 中的所有键值对。它接受一个函数作为参数，该函数会被应用于每一个键值对。如果函数返回 false，迭代将停止。

m.Range(func(key, value interface{}) bool {
    fmt.Println(key, value)
    return true
})

CompareAndDelete

CompareAndDelete 方法在 Go 1.20 中引入，用于在并发环境中安全地删除特定的键值对。它会检查指定键的当前值是否与提供的旧值相匹配，如果匹配，则删除该键值对。

deleted := m.CompareAndDelete("key", "oldValue")
if deleted {
    fmt.Println("Key successfully deleted.")
} else {
    fmt.Println("Key deletion failed.")
}

CompareAndSwap

CompareAndSwap 方法同样在 Go 1.20 中引入，用于在并发环境中安全地更新特定键的值。它会检查指定键的当前值是否与提供的旧值相匹配，如果匹配，则将其更新为新值。

swapped := m.CompareAndSwap("key", "oldValue", "newValue")
if swapped {
    fmt.Println("Value successfully updated.")
} else {
    fmt.Println("Value update failed.")
}

使用场景与最佳实践

sync.Map 由于其并发安全的特性，特别适用于以下场景：

  • 高并发读取： 当应用程序需要频繁读取共享数据时，sync.Map 能够提供更高的性能和更好的缩放性。
  • 读多写少： 在读操作远多于写操作的场景中，sync.Map 的性能优势更加明显。
  • 无需精细锁控制： 对于简单的共享映射，使用 sync.Map 可以避免手动管理互斥锁（如 sync.RWMutex），简化代码结构。

然而，在写操作频繁或需要复杂操作时，sync.Map 可能并不适用，传统的互斥锁或其他并发控制机制可能更为合适。

示例代码

基本操作示例

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map

    // 存储键值对
    m.Store("name", "Alice")
    m.Store("age", 30)

    // 加载并打印值
    if name, ok := m.Load("name"); ok {
        fmt.Println("Name:", name)
    }

    // 使用 LoadOrStore
    actual, loaded := m.LoadOrStore("country", "USA")
    if loaded {
        fmt.Println("Country already set to:", actual)
    } else {
        fmt.Println("Country set to:", actual)
    }

    // 更新值使用 CompareAndSwap
    success := m.CompareAndSwap("age", 30, 31)
    if success {
        fmt.Println("Age updated to 31.")
    }

    // 遍历所有键值对
    m.Range(func(key, value interface{}) bool {
        fmt.Printf("%s: %v\n", key, value)
        return true
    })

    // 删除键
    m.Delete("country")
    fmt.Println("Country key deleted.")

    // 尝试加载被删除的键
    if _, ok := m.Load("country"); !ok {
        fmt.Println("Country key not found.")
    }
}

并发使用示例

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    var wg sync.WaitGroup

    // 开启多个 goroutine 并发存储数据
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key%d", i)
            m.Store(key, i)
        }(i)
    }

    wg.Wait()

    // 并发读取数据
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key%d", i)
            if value, ok := m.Load(key); ok {
                fmt.Printf("Loaded %s: %v\n", key, value)
            }
        }(i)
    }

    wg.Wait()
}

注意事项

  • 性能优化： 虽然 sync.Map 在并发场景下性能优越，但在读写操作均衡或写操作频繁的场景下，传统的 map 配合 sync.RWMutex 可能表现更好。
  • 类型安全： sync.Map 的键和值类型均为 interface{}，因此在使用时需要进行类型断言，可能带来一定的类型不安全风险。
  • 内存管理： 由于 sync.Map 内部使用了复杂的数据结构以优化并发性能，可能会比普通的 map 占用更多的内存。

与传统 map 及锁机制的比较

传统的 map 在并发场景下需要配合锁机制（如 sync.Mutex 或 sync.RWMutex）来确保线程安全性。而 sync.Map 提供了一种无需显式锁控制的解决方案，简化了代码并在特定场景下提供了更好的性能。

传统 map 与锁机制示例

package main

import (
    "fmt"
    "sync"
)

func main() {
    m := make(map[string]int)
    var mutex sync.RWMutex
    var wg sync.WaitGroup

    // 写操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            mutex.Lock()
            m[fmt.Sprintf("key%d", i)] = i
            mutex.Unlock()
        }(i)
    }

    // 读操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            mutex.RLock()
            fmt.Printf("key%d: %d\n", i, m[fmt.Sprintf("key%d", i)])
            mutex.RUnlock()
        }(i)
    }

    wg.Wait()
}

sync.Map 示例回顾

相比之下，使用 sync.Map 可以免去手动管理锁的复杂性，代码更为简洁：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    var wg sync.WaitGroup

    // 写操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            m.Store(fmt.Sprintf("key%d", i), i)
        }(i)
    }

    // 读操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            if value, ok := m.Load(fmt.Sprintf("key%d", i)); ok {
                fmt.Printf("key%d: %v\n", i, value)
            }
        }(i)
    }

    wg.Wait()
}

参考资料

pkg.go.dev
Go 官方文档 - sync.Map
golang.org
Go 语言官方 sync 包文档
go.dev
Go 1.20 发行说明

总结

Go 的 sync.Map 提供了一种简单且高效的方式来处理并发环境下的映射数据。自 Go 1.9 引入以来，其基本 API 保持了稳定性，并在 Go 1.20 中进一步增强了功能。通过合理利用 sync.Map，开发者可以编写出更简洁、更高性能的并发代码。然而，选择合适的数据结构和并发控制机制仍需根据具体的应用场景进行权衡。


Last updated January 3, 2025

AI-assisted research. Sources, methodology and corrections · Source-checked guides and tools · Explore published answers

Ask Ithy AI