Golang如何实现无锁并发数据结构详解CAS操作与atomic包实战应用-Golang-PHP中文网

Golang如何实现无锁并发数据结构详解CAS操作与atomic包实战应用

P粉602998670

发布： 2025-08-08 08:01:01

原创

247人浏览过

golang中实现无锁并发数据结构的核心方式是利用cas操作和sync/atomic包。1. cas是一种原子操作，通过比较当前值与预期值是否一致来决定是否更新值，确保线程安全；2. sync/atomic包提供了compareandswapint32、compareandswappointer等方法用于构建无锁结构；3. 使用atomic.int64等封装类型可简化无锁计数器实现；4. 构建无锁队列需结合cas与链表或环形缓冲区，注意aba问题及内存屏障；5. 无锁结构适用于轻度并发场景，但调试难度大且在高竞争环境下可能性能下降。

Golang如何实现无锁并发数据结构详解CAS操作与atomic包实战应用

在高并发场景下，使用锁虽然能保证数据一致性，但会带来性能瓶颈。Golang中实现无锁并发数据结构的核心方式是利用CAS（Compare And Swap）操作和

sync/atomic

登录后复制

包。这种方式避免了互斥锁带来的阻塞问题，提高了程序的吞吐能力。

什么是CAS操作？

CAS 是一种原子操作，它的基本逻辑是：比较当前值是否等于预期值，如果是，则将其更新为新值；否则不做任何操作。这个过程是不可中断的，因此是线程安全的。

Go 的

sync/atomic

登录后复制

包提供了多个 CAS 相关的方法，例如

CompareAndSwapInt32

登录后复制

、

CompareAndSwapPointer

登录后复制

等。这些方法可以用于构建无锁队列、栈、计数器等数据结构。

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

举个例子：

var value int32 = 0
swapped := atomic.CompareAndSwapInt32(&value, 0, 1)
// 如果 value 当前是 0，就会被设置为 1，返回 true；否则返回 false

登录后复制

这种方式非常适合用在状态变更或资源竞争不激烈的场景中。

使用atomic包实现一个简单的无锁计数器

假设我们想实现一个并发安全的计数器，又不想用互斥锁，可以用

atomic.Int64

登录后复制

类型（Go 1.19+ 支持）来轻松实现：

package main

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

func main() {
    var counter atomic.Int64
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Add(1)
        }()
    }

    wg.Wait()
    fmt.Println("Counter:", counter.Load())
}

登录后复制

在这个例子中，

Add

登录后复制

和

Load

登录后复制

都是原子操作，不需要加锁就能确保线程安全。如果你用普通变量配合 goroutine 增加计数，结果可能会出错。

注意几点：

即构数智人

即构数智人是由即构科技推出的AI虚拟数字人视频创作平台，支持数字人形象定制、短视频创作、数字人直播等。

查看详情

不要试图手动用多个原子操作组合成“事务”，这样容易引入竞态。
尽量使用 Go 提供的封装类型如
```
atomic.Int64
```
登录后复制
、
```
atomic.Pointer
```
登录后复制
等，更简洁也更安全。

构建无锁队列的基本思路

如果你想自己写一个无锁队列，通常需要结合 CAS 操作 + 环形缓冲区或链表结构。

以单生产者单消费者模型为例，你可以用两个指针（head 和 tail）分别指向读写位置，并通过 CAS 来更新它们。比如：

type Node struct {
    val  interface{}
    next *Node
}

type LockFreeQueue struct {
    head *Node
    tail *Node
}

func (q *LockFreeQueue) Enqueue(val interface{}) {
    newNode := &Node{val: val}
    for {
        oldTail := atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&q.tail)))
        next := (*Node)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&(*oldTail).next))))
        if next != nil {
            // 队列尾部可能有其他线程在操作，尝试推进 tail
            atomic.CompareAndSwapPointer(
                (*unsafe.Pointer)(unsafe.Pointer(&q.tail)),
                oldTail,
                unsafe.Pointer(next),
            )
            continue
        }
        // 尝试将新节点插入到 tail 后面
        if atomic.CompareAndSwapPointer(
            (*unsafe.Pointer)(unsafe.Pointer(&(*oldTail).next)),
            nil,
            unsafe.Pointer(newNode),
        ) {
            // 成功插入后更新 tail
            atomic.CompareAndSwapPointer(
                (*unsafe.Pointer)(unsafe.Pointer(&q.tail)),
                oldTail,
                unsafe.Pointer(newNode),
            )
            return
        }
    }
}

登录后复制

上面这段代码是一个简化的无锁队列入队逻辑，实际使用时要考虑更多边界情况，比如内存屏障、ABA问题等。

关键点总结：