Go语言接口防并发常用方案

原创枫潇潇兮程序员技术成长之路 2024-01-09 08:30 发表于福建听全文

Go语言中处理并发的常见策略涉及了并发原语，如互斥锁（sync.Mutex）、读写锁（sync.RWMutex）、通道（channel）以及原子操作（sync/atomic）。接口（Interface）本身并不直接参与并发控制，但是当多个协程（goroutine）需要访问满足某个接口的对象时，你需要考虑如何避免竞态条件（race conditions）。

以下是一些防并发的常用方案：

互斥锁（Mutex）：使用sync.Mutex来确保同一时间只有一个协程可以访问共享资源。

type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    c.count++
    c.mu.Unlock()
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

2. 读写锁（RWMutex）：如果你的接口涉及到读写操作，并且读操作远多于写操作，sync.RWMutex是一个更好的选择。它允许多个协程同时读取而不用加锁，但写入时会阻止其他读或写操作。

type SafeCache struct {
    mu    sync.RWMutex
    cache map[string]string
}

func (c *SafeCache) Get(key string) string {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.cache[key]
}

func (c *SafeCache) Set(key string, value string) {
    c.mu.Lock()
    c.cache[key] = value
    c.mu.Unlock()
}

3.原子操作：对于简单的计数器，你可能使用sync/atomic包中的原子操作，这些操作能够保证对类型如int32, int64, uint32, uint64, uintptr 和 unsafe.Pointer等类型的并发安全访问。

var count int32

func Increment() {
    atomic.AddInt32(&count, 1)
}

func GetCount() int32 {
    return atomic.LoadInt32(&count)
}

4. 通道（Channel）：另一种同步方式是使用通道来传递数据。当处理接口方法的对象需要协程安全时，可以使用通道来同步协程间的通信，确保并发访问的安全性。

type SafeChannelData struct {
    Channel chan int
}

func NewSafeChannelData() *SafeChannelData {
    return &SafeChannelData{
        Channel: make(chan int, 1), // 带缓冲的通道可以防止阻塞
    }
}

func (scd *SafeChannelData) WriteData(data int) {
    scd.Channel <- data
}

func (scd *SafeChannelData) ReadData() int {
    return <-scd.Channel
}