C++ 无锁编程

原创于 2025-03-04 17:45:13 发布 · 491 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

#c++

C++ 专栏收录该内容

8 篇文章

订阅专栏

C++ 无锁编程介绍

1. 什么是无锁编程？

无锁编程（Lock-Free Programming） 是一种并发编程范式，其核心目标是避免使用传统互斥锁（如 mutex），通过原子操作和内存顺序保证线程安全。它要求至少一个线程能够在有限步内完成操作，从而避免死锁和优先级反转等问题。与基于锁的编程相比，无锁设计通常能提高并发性能，尤其在低竞争场景下。

2. 无锁编程的优势

避免阻塞：线程无需等待锁释放，减少上下文切换。
消除死锁风险：无锁代码不涉及锁的嵌套获取。
高吞吐量：在高并发场景下，减少锁竞争带来的性能损耗。
实时性：适用于实时系统，保证操作的可预测性。

3. C++ 的无锁工具

原子操作（Atomic Operations）

C++11 引入 std::atomic<T> 模板类，支持对整数、指针等类型的原子操作：

#include <atomic>
std::atomic<int> counter{0};

void increment() {
    counter.fetch_add(1, std::memory_order_relaxed); // 原子自增
}

常用原子操作：

load()：原子读取。
store()：原子写入。
exchange()：交换值。
compare_exchange_weak/strong()：CAS（比较并交换）操作。

内存顺序（Memory Order）

定义原子操作的内存可见性顺序，避免不必要的同步开销：

memory_order_relaxed：无顺序保证，仅原子性。
memory_order_acquire：当前操作的读取在后续操作前完成（读屏障）。
memory_order_release：当前操作的写入在后续操作前可见（写屏障）。
memory_order_seq_cst：严格顺序一致性（默认，性能较低）。

4. 无锁数据结构示例：无锁栈

#include <atomic>

template<typename T>
class LockFreeStack {
private:
    struct Node {
        T data;
        Node* next;
        Node(const T& d) : data(d), next(nullptr) {}
    };

    std::atomic<Node*> head;

public:
    void push(const T& data) {
        Node* new_node = new Node(data);
        new_node->next = head.load(std::memory_order_relaxed);
        while (!head.compare_exchange_weak(new_node->next, new_node,
                                          std::memory_order_release,
                                          std::memory_order_relaxed));
    }

    bool pop(T& result) {
        Node* old_head = head.load(std::memory_order_acquire);
        while (old_head &&
               !head.compare_exchange_weak(old_head, old_head->next,
                                           std::memory_order_release,
                                           std::memory_order_relaxed));
        if (!old_head) return false;
        result = old_head->data;
        delete old_head; // 注意：需处理内存回收问题（如风险指针）
        return true;
    }
};

该栈使用 compare_exchange_weak 实现无锁的压入和弹出操作，但需注意内存回收问题（如ABA问题）。

5. 挑战与解决方案

ABA问题：
- 问题：线程A读取值A，中间值被改为B后又改回A，导致CAS误判。
- 解决：使用带版本号的指针（如 std::atomic<std::shared_ptr>）或延迟内存回收（如风险指针、epoch-based回收）。
内存回收：
- 无锁数据结构需谨慎处理节点删除，避免访问已释放内存。可采用垃圾回收机制或引用计数。
正确性验证：
- 通过压力测试（如多个线程高频操作）、静态分析工具（如Clang ThreadSanitizer）检测数据竞争。