【Golang】Golang中有哪些方式可以进行安全读写共享变量

---

前言

在并发编程中，安全地读写共享变量是一个非常重要的问题。Go语言（Golang）提供了多种机制来确保在多线程环境下对共享变量的安全访问。本文将介绍几种常见的方式，包括sync.Mutex、sync.RWMutex、sync/atomic、channel和sync.Map，并通过代码示例展示如何使用这些机制。

---

一、介绍

1. sync.Mutex

sync.Mutex是Go语言中最基本的互斥锁，用于保护共享资源的读写。它通过锁定和解锁来确保同一时间只有一个goroutine可以访问共享变量。

2. sync.RWMutex

sync.RWMutex是一种读写锁，允许多个读操作同时进行，但写操作是互斥的。它比sync.Mutex更适合读多写少的场景。

3. sync/atomic

sync/atomic包提供了底层的原子操作，可以对整数和指针类型进行原子读写操作，适用于简单的计数器或标志位等场景。

4. channel

channel是Go语言中的一种通信机制，可以用来在多个goroutine之间安全地传递数据。通过channel可以实现对共享变量的安全读写。

5. sync.Map

sync.Map是Go 1.9引入的一种并发安全的map，适用于需要频繁读写的场景。

二、代码实现

2.1 使用sync.Mutex

package main

import (
    "fmt"
    "sync"
)

var (
    mutex     sync.Mutex
    sharedVar int
)

func read() {
    mutex.Lock()
    defer mutex.Unlock()
    fmt.Println("Read:", sharedVar)
}

func write(value int) {
    mutex.Lock()
    defer mutex.Unlock()
    sharedVar = value
    fmt.Println("Write:", sharedVar)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        read()
    }()

    go func() {
        defer wg.Done()
        write(42)
    }()

    wg.Wait()
}

2.2 使用sync.RWMutex

package main

import (
    "fmt"
    "sync"
)

var (
    rwMutex   sync.RWMutex
    sharedVar int
)

func read() {
    rwMutex.RLock()
    defer rwMutex.RUnlock()
    fmt.Println("Read:", sharedVar)
}

func write(value int) {
    rwMutex.Lock()
    defer rwMutex.Unlock()
    sharedVar = value
    fmt.Println("Write:", sharedVar)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        read()
    }()

    go func() {
        defer wg.Done()
        write(42)
    }()

    wg.Wait()
}

2.3. 使用sync/atomic

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var sharedVar int64

func read() {
    value := atomic.LoadInt64(&sharedVar)
    fmt.Println("Read:", value)
}

func write(value int64) {
    atomic.StoreInt64(&sharedVar, value)
    fmt.Println("Write:", value)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        read()
    }()

    go func() {
        defer wg.Done()
        write(42)
    }()

    wg.Wait()
}

2.4使用channel

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)
    done := make(chan bool)

    // Writer goroutine
    go func() {
        ch <- 42
        done <- true
    }()

    // Reader goroutine
    go func() {
        value := <-ch
        fmt.Println("Read:", value)
        done <- true
    }()

    // Wait for both goroutines to finish
    <-done
    <-done
}

2.4使用sync.Map

package main

import (
    "fmt"
    "sync"
)

var sharedMap sync.Map

func read(key string) {
    if value, ok := sharedMap.Load(key); ok {
        fmt.Println("Read:", value)
    } else {
        fmt.Println("Key not found")
    }
}

func write(key string, value interface{}) {
    sharedMap.Store(key, value)
    fmt.Println("Write:", value)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        defer wg.Done()
        write("key1", 42)
    }()

    go func() {
        defer wg.Done()
        read("key1")
    }()

    wg.Wait()
}

---

三、总结

在Go语言中，安全地读写共享变量是并发编程中的一个重要问题。本文介绍了几种常见的方法，包括sync.Mutex、sync.RWMutex、sync/atomic、channel和sync.Map。每种方法都有其适用的场景和优缺点：

• sync.Mutex：适用于需要简单互斥锁的场景。
• sync.RWMutex：适用于读多写少的场景。
• sync/atomic：适用于简单的计数器或标志位等场景。
• channel：适用于需要在多个goroutine之间传递数据的场景。
• sync.Map：适用于需要频繁读写的并发场景。

根据具体的应用场景选择合适的并发控制方式，可以提高程序的性能和可维护性。希望本文能帮助你更好地理解和使用Go语言中的并发控制机制。