深入理解原子类与CAS无锁编程：原理、实战与优化-CSDN博客

深入理解原子类与CAS无锁编程：原理、实战与优化

1. 引言：并发编程的挑战

在多线程环境中，共享数据的同步访问是核心挑战。传统锁机制（如synchronized）存在性能瓶颈：线程阻塞、上下文切换、死锁风险。无锁编程通过硬件级原子指令实现线程安全，大幅提升并发性能。

2. 核心原理剖析

2.1 原子操作三要素

// 非原子操作示例
var counter = 0
fun unsafeIncrement() {
    counter++ // 包含读取->计算->写入三步操作
}

问题：当多线程同时执行时，可能发生更新丢失。

2.2 CAS 工作原理

CPU 指令伪代码：

fun compareAndSwap(memory: Memory, expected: Int, newValue: Int): Boolean {
    if (memory.value == expected) {
        memory.value = newValue
        return true
    }
    return false
}

硬件保证：整个比较和交换过程是原子的，不会被线程切换打断。

2.3 原子类实现机制

// AtomicInteger 核心源码解析（简化版）
class AtomicInteger(private var value: Int) {
    fun get(): Int = value
    
    fun compareAndSet(expect: Int, update: Int): Boolean {
        return if (value == expect) {
            value = update
            true
        } else false
    }

    fun incrementAndGet(): Int {
        while (true) {
            val current = get()
            val next = current + 1
            if (compareAndSet(current, next)) return next
        }
    }
}

循环CAS流程：

[Start] → Read Current Value → Compute New Value → CAS操作 → 
       ├─成功→ Return Result
       └─失败→ Retry from Start

3. 原子类实战（Kotlin）

3.1 基础计数器

import java.util.concurrent.atomic.AtomicInteger

fun main() {
    val atomicCounter = AtomicInteger(0)
    
    // 启动100个线程并发计数
    (1..100).map {
        thread {
            repeat(1000) { atomicCounter.incrementAndGet() }
        }
    }.forEach { it.join() }

    println("Final count: ${atomicCounter.get()}") // 正确输出100000
}

3.2 状态标志管理

val isActive = AtomicBoolean(false)

fun startService() {
    if (isActive.compareAndSet(false, true)) {
        println("Service started")
    } else {
        println("Service already running")
    }
}

3.3 无锁栈实现（Treiber Stack）

class LockFreeStack<T> {
    private val top = AtomicReference<Node<T>?>(null)

    fun push(item: T) {
        val newNode = Node(item)
        while (true) {
            val currentTop = top.get()
            newNode.next = currentTop
            if (top.compareAndSet(currentTop, newNode)) return
        }
    }

    fun pop(): T? {
        while (true) {
            val currentTop = top.get() ?: return null
            val newTop = currentTop.next
            if (top.compareAndSet(currentTop, newTop)) return currentTop.item
        }
    }

    private class Node<T>(val item: T, var next: Node<T>? = null)
}

4. 解决ABA问题

4.1 ABA问题复现

线程1：读取值 A
线程2：修改 A → B → A
线程1：CAS比较值仍为A，操作成功（但中间状态已改变）

4.2 带版本号的解决方案

val atomicRef = AtomicStampedReference("A", 0)

// 线程1
val (initialRef, initialStamp) = atomicRef.get()
// ... 其他操作 ...

// 线程2
atomicRef.set("B", initialStamp + 1)
atomicRef.set("A", initialStamp + 2)

// 线程1的CAS操作
val success = atomicRef.compareAndSet(
    initialRef, 
    "NewValue",
    initialStamp, // 检测原始版本号
    initialStamp + 1
)

5. 性能对比测试

fun testPerformance() {
    val lockCounter = AtomicInteger(0)
    val syncCounter = object {
        @Synchronized 
        fun inc() = lockCounter.incrementAndGet()
    }

    // 测试CAS性能
    time("CAS") {
        (1..1000).map {
            thread { repeat(100_000) { lockCounter.incrementAndGet() } }
        }.forEach { it.join() }
    }

    // 测试同步锁性能
    time("Synchronized") {
        (1..1000).map {
            thread { repeat(100_000) { syncCounter.inc() } }
        }.forEach { it.join() }
    }
}

fun time(label: String, block: () -> Unit) {
    val start = System.nanoTime()
    block()
    println("$label time: ${(System.nanoTime() - start) / 1e9}s")
}

测试结果（4核CPU）：

CAS time: 2.34s
Synchronized time: 8.71s

结论：低竞争时CAS性能优势明显，高竞争时需考虑LongAdder分段计数

6. 最佳实践指南

适用场景选择：
- 优先用于简单原子操作（计数、标志位）
- 复杂数据结构推荐使用ConcurrentHashMap等线程安全集合
ABA问题防御：
- 使用AtomicStampedReference跟踪版本号
- 或AtomicMarkableReference添加布尔标记

高竞争优化：

// 使用LongAdder替代AtomicLong
val adder = LongAdder()
fun add() = adder.increment()
fun sum() = adder.sum()

内存可见性：
- 原子类保证happens-before语义
- 无需额外加volatile

7. 关键点总结

特性	锁机制	CAS无锁
线程阻塞	可能阻塞	永不阻塞
死锁风险	存在	不存在
性能（低竞争）	较差	极佳
性能（高竞争）	稳定	可能劣化
实现复杂度	简单	复杂
ABA问题	无	需额外处理
适用场景	临界区复杂操作	简单原子操作/无锁数据结构