Go语言并发Map读写安全详解

一分耕耘，一分收获！既然打开了这篇文章《Go语言并发Map读写安全解析》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

在Go语言中，当程序存在并发访问Map时，如果至少有一个写入操作存在，那么所有对Map的读取和写入操作都必须进行同步，以避免数据竞争和不一致性。纯粹的多读无写或单写无读场景是安全的，但一旦涉及读写并发或多写，sync.Mutex或sync.RWMutex等同步原语是不可或缺的。

Go语言中并发Map访问的挑战

Go语言内置的map类型并非并发安全的。这意味着在多个goroutine同时访问同一个map，并且至少有一个goroutine进行写入操作时，会发生数据竞争（data race），可能导致程序崩溃（panic）、数据损坏或不可预测的行为。即使是看似无害的读取操作，在有写入并发发生时也可能读取到不一致或损坏的数据。

Map并发访问的安全原则

理解Map并发访问的安全性，可以遵循以下核心原则：

1. 多读无写（Multiple Readers, No Writers）： 当多个goroutine同时读取一个map，并且没有任何goroutine进行写入操作时，这种场景是安全的。因为读取操作不会修改map的内部结构，所以不会发生数据竞争。

2. 单写无读（One Writer, No Readers）： 当一个goroutine对map进行写入操作，并且没有其他goroutine同时进行读取或写入操作时，这种场景也是安全的。这是map的基本功能，如果连这都不安全，map将毫无用处。

3. 读写并发或多写（At Least One Writer + Any Other Access）： 这是最需要关注的场景。如果存在至少一个写入操作，并且同时有其他goroutine进行读取或写入操作，那么所有对该map的访问（包括读和写）都必须进行同步。在这种情况下，不加同步的读取操作也可能导致问题，因为写入操作可能正在修改map的底层数据结构，导致读取操作访问到不完整或无效的数据。

为何读操作也需要同步？

许多初学者可能会疑惑，为什么在有写入操作时，读取操作也需要同步？原因在于map的内部实现。当一个map进行写入（例如插入、更新或删除键值对）时，它可能会重新分配内存、调整哈希桶结构等。如果在这些操作进行到一半时，另一个goroutine尝试读取map，它可能会遇到：

• 不完整的状态：读取到正在修改中的数据结构，导致读取错误。
• 数据损坏：访问到无效的内存地址，导致程序崩溃（panic）。
• 竞争条件：读取到旧值或新值，取决于调度时机，导致不可预测的结果。

因此，为了保证数据一致性和程序稳定性，只要有写入者存在，所有的读写操作都必须通过同步机制进行协调。

使用 sync.Mutex 实现同步

sync.Mutex（互斥锁）是Go语言中最常用的同步原语之一，可以用来保护共享资源，确保在任何给定时刻只有一个goroutine能够访问该资源。

示例：不安全的并发访问

以下是一个不安全的并发Map访问示例，它很可能会导致fatal error: concurrent map writes：

package main

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

func main() {
    m := make(map[int]int)
    wg := sync.WaitGroup{}

    // 启动多个goroutine进行写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                m[id*100+j] = id // 写入操作
            }
        }(i)
    }

    // 启动一个goroutine进行读取（即使是读，在有写并发时也可能出问题）
    wg.Add(1)
    go func() {
        defer wg.Done()
        for k := 0; k < 100; k++ {
            // 尝试读取，在有写入并发时可能读取到不一致数据或panic
            _ = m[k]
            time.Sleep(time.Millisecond) // 模拟读取耗时
        }
    }()

    wg.Wait()
    fmt.Println("Map size:", len(m))
}

示例：使用 sync.Mutex 进行读写同步

为了安全地进行并发访问，我们需要引入一个sync.Mutex来保护map。

package main

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

// SafeMap 结构体，包含一个map和一个互斥锁
type SafeMap struct {
    mu sync.Mutex
    m  map[int]int
}

// NewSafeMap 创建并返回一个新的SafeMap
func NewSafeMap() *SafeMap {
    return &SafeMap{
        m: make(map[int]int),
    }
}

// Set 方法安全地写入map
func (sm *SafeMap) Set(key, value int) {
    sm.mu.Lock()   // 加锁
    defer sm.mu.Unlock() // 解锁
    sm.m[key] = value
}

// Get 方法安全地读取map
func (sm *SafeMap) Get(key int) (int, bool) {
    sm.mu.Lock()   // 加锁
    defer sm.mu.Unlock() // 解锁
    val, ok := sm.m[key]
    return val, ok
}

// Len 方法安全地获取map长度
func (sm *SafeMap) Len() int {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    return len(sm.m)
}

func main() {
    safeMap := NewSafeMap()
    wg := sync.WaitGroup{}

    // 启动多个goroutine进行写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                safeMap.Set(id*100+j, id) // 安全写入
            }
        }(i)
    }

    // 启动一个goroutine进行读取
    wg.Add(1)
    go func() {
        defer wg.Done()
        for k := 0; k < 100; k++ {
            val, ok := safeMap.Get(k) // 安全读取
            if ok {
                // fmt.Printf("Read key %d: %d\n", k, val)
            }
            time.Sleep(time.Millisecond) // 模拟读取耗时
        }
    }()

    wg.Wait()
    fmt.Println("SafeMap size:", safeMap.Len()) // 安全获取长度
}

在这个示例中，我们将map封装在一个SafeMap结构体中，并嵌入一个sync.Mutex。Set、Get和Len等方法在访问底层map之前都会先调用sm.mu.Lock()加锁，操作完成后再调用defer sm.mu.Unlock()解锁。这样就确保了在任何给定时刻，只有一个goroutine能够访问map，从而避免了数据竞争。

优化：sync.RWMutex的优势

sync.Mutex在任何时候都只允许一个goroutine访问共享资源，这对于写操作频繁的场景是合适的。但如果你的应用场景是读操作远多于写操作，那么sync.RWMutex（读写互斥锁）会是更高效的选择。

sync.RWMutex的特性：

• 写锁（Lock/Unlock）：与sync.Mutex类似，一次只允许一个写入者持有写锁。当写锁被持有，所有读锁和写锁都会被阻塞。
• 读锁（RLock/RUnlock）：允许多个读取者同时持有读锁。只要没有写锁被持有，任意数量的读取者都可以同时获取读锁。当读锁被持有，写锁会被阻塞。

使用sync.RWMutex改造SafeMap：

package main

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

type RWSafeMap struct {
    mu sync.RWMutex
    m  map[int]int
}

func NewRWSafeMap() *RWSafeMap {
    return &RWSafeMap{
        m: make(map[int]int),
    }
}

// Set 方法使用写锁保护写入操作
func (sm *RWSafeMap) Set(key, value int) {
    sm.mu.Lock()   // 获取写锁
    defer sm.mu.Unlock() // 释放写锁
    sm.m[key] = value
}

// Get 方法使用读锁保护读取操作
func (sm *RWSafeMap) Get(key int) (int, bool) {
    sm.mu.RLock()   // 获取读锁
    defer sm.mu.RUnlock() // 释放读锁
    val, ok := sm.m[key]
    return val, ok
}

// Len 方法使用读锁保护读取操作
func (sm *RWSafeMap) Len() int {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    return len(sm.m)
}

func main() {
    rwSafeMap := NewRWSafeMap()
    wg := sync.WaitGroup{}

    // 启动多个goroutine进行写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                rwSafeMap.Set(id*100+j, id)
            }
        }(i)
    }

    // 启动大量goroutine进行读取
    for i := 0; i < 10; i++ { // 更多读者
        wg.Add(1)
        go func(readerID int) {
            defer wg.Done()
            for k := 0; k < 100; k++ {
                val, ok := rwSafeMap.Get(k)
                if ok {
                    // fmt.Printf("Reader %d: Read key %d: %d\n", readerID, k, val)
                }
                time.Sleep(time.Millisecond / 2) // 模拟读取耗时，比写入快
            }
        }(i)
    }

    wg.Wait()
    fmt.Println("RWSafeMap size:", rwSafeMap.Len())
}

在读多写少的场景下，sync.RWMutex能够显著提高并发性能，因为它允许并发的读操作。

注意事项与最佳实践

• 封装共享资源：将map和其对应的sync.Mutex或sync.RWMutex封装在一个结构体中，并提供访问方法，是管理共享资源的最佳实践。这有助于确保所有访问都经过同步。
• 避免死锁：确保加锁和解锁操作配对，并且避免在持有锁的情况下尝试获取另一个可能被当前goroutine或其依赖的goroutine持有的锁，这可能导致死锁。
• 选择合适的同步机制：
  • sync.Mutex：简单直观，适用于读写频率相近或写操作较多的场景。
  • sync.RWMutex：适用于读操作远多于写操作的场景，能提供更好的并发性能。
  • sync.Map：Go 1.9 引入的并发Map，针对特定高并发场景（如键值对不经常更新但经常读取）进行了优化，无需显式使用锁。但它有其特定的性能特点和使用场景，不应作为map的通用替代品。对于一般情况，手动封装map加sync.Mutex或sync.RWMutex通常更灵活和易于理解。

总结

Go语言的map类型本身不是并发安全的。当存在并发写入操作时，即使是读取操作也必须通过同步机制（如sync.Mutex或sync.RWMutex）进行保护，以防止数据竞争、程序崩溃或数据不一致。通过将map和同步原语封装在一个自定义类型中，并提供线程安全的方法，可以有效地管理并发访问，确保程序的健壮性和正确性。在读多写少的场景下，优先考虑使用sync.RWMutex以提升性能。

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~