golang并发编程中的数据竞争与资源争用

数据竞争是多个 goroutine 并发访问共享数据而无同步保护，解决方案包括使用互斥锁和读写锁。资源争用是多个 goroutine 争抢稀缺资源，可通过资源限额、并发队列和死锁检测解决。实战案例提供了线程安全计数器和使用并发队列共享资源的示例。

Go 语言并发编程中的数据竞争与资源争用

简介

在并发编程中，数据竞争和资源争用是常见的错误来源，如果不妥善解决，会引发难以调试的问题。本文将探讨如何在 Go 语言中识别和解决这些问题，并提供实战案例以加深理解。

数据竞争

立即学习“go语言免费学习笔记（深入）”；

数据竞争是指多个 goroutine 并发访问共享数据而没有同步保护，导致数据不一致。例如：

var counter int

func incrementCounter() {
    counter++
}

func decrementCounter() {
    counter--
}

func main() {
    waitGroup := new(sync.WaitGroup)
    waitGroup.Add(2)

    go func() {
        for i := 0; i < 100; i++ {
            incrementCounter()
        }
        waitGroup.Done()
    }()

    go func() {
        for i := 0; i < 100; i++ {
            decrementCounter()
        }
        waitGroup.Done()
    }()

    waitGroup.Wait()
    fmt.Println(counter) // 输出可以是任意值
}

在这个例子中，counter 变量在多个 goroutine 之间共享，但在没有同步的情况下被并发访问，可能会导致数据竞争。

解决方法：

织梦团购系统DEDE5

织梦DEDE5凭借其专业的技术、丰富的电子商务经验在第一时刻为此最流行的购物方式推出开源程序。独立编译模板、自由修改、代码简洁，安全高效、数据缓存等技术的应用，使其能在大浏览量的环境下快速稳定运行，切实节约网站成本，提升形象。同行业比较，织梦DEDE5的优势在哪里？整体规划 摒弃开发速度慢，效率低下、冗余严重的框架。投入大量的时间和精力，打造最简洁高效的程序开源程序 我们渴望公平、公正、开放的竞争

下载

• 使用互斥锁（sync.Mutex）：互斥锁允许一次只允许一个 goroutine 访问共享数据，从而防止数据竞争。
• 使用读写锁（sync.RWMutex）：读写锁将锁分为读锁和写锁，允许多个 goroutine并发读取共享数据，同时只能由一个 goroutine写入数据。

资源争用

资源争用是指多个 goroutine 竞争同一有限资源，例如 CPU 时间或内存，导致性能下降。例如：

var channel = make(chan int, 1)

func sendChannelData() {
    for {
        channel <- 1
    }
}

func receiveChannelData() {
    for {
        <-channel
    }
}

func main() {
    go sendChannelData()
    go receiveChannelData()
}

在这个例子中，两个 goroutine 竞争写入和读取同一通道 channel。这会导致 goroutine 交替执行，性能明显下降。

解决方法：

• 使用资源限额：限制每个 goroutine 或线程可以使用的资源量。
• 使用并发队列：使用并发队列来管理共享资源的访问，例如 sync.Pool 或 channels，以确保公平的访问。
• 使用死锁检测：在 Go 语言中，可以使用 runtime.GOMAXPROCS 函数和 runtime.NumGoroutine 函数来检测和避免死锁。

实战案例

一个共享资源的线程安全的计数器

import (
    "sync/atomic"
)

type ThreadsafeCounter struct {
    value int64
}

func (c *ThreadsafeCounter) Increment() {
    atomic.AddInt64(&c.value, 1)
}

func (c *ThreadsafeCounter) Decrement() {
    atomic.AddInt64(&c.value, -1)
}

func (c *ThreadsafeCounter) Value() int64 {
    return atomic.LoadInt64(&c.value)
}

一个使用并发队列的共享资源

import (
    "sync"
    "container/list"
)

type ConcurrentQueue struct {
    items *list.List
    lock  sync.Mutex
}

func NewConcurrentQueue() *ConcurrentQueue {
    return &ConcurrentQueue{
        items: list.New(),
    }
}

func (q *ConcurrentQueue) Push(item interface{}) {
    q.lock.Lock()
    defer q.lock.Unlock()
    q.items.PushBack(item)
}

func (q *ConcurrentQueue) Pop() (item interface{}, ok bool) {
    q.lock.Lock()
    defer q.lock.Unlock()
    if q.items.Len() > 0 {
        item = q.items.Remove(q.items.Front())
        return item, true
    }
    return nil, false
}