concurrency

# 并发与并行编程 ## 原子操作与内存序 cpp #include #include // 基础原子类型 std::atomic counter{0}; std::atomic flag{false}; // 内存序 void producer(std::atomic& data, std::atomic& ready) { data.store(42, std::memory_order_relaxed); ready.store(true, std::memory_order_release); // 释放屏障 } void consumer(std::atomic& data, std::atomic& ready) { while (!ready.load(std::memory_order_acquire)) { // 获取屏障 std::this_thread::yield(); } int value = data.load(std::memory_order_relaxed); } // 比较并交换 (CAS) bool try_acquire_lock(std::atomic& lock) { bool expected = false; return lock.compare_exchange_strong(expected, true, std::memory_order_acquire, std::memory_order_relaxed); } // 获取并增加 int increment_counter(std::atomic& counter) { return counter.fetch_add(1, std::memory_order_relaxed); } ## 无锁数据结构 cpp #include #include // 无锁栈 template class LockFreeStack { struct Node { T data; Node* next; Node(const T& value) : data(value), next(nullptr) {} }; std::atomic head_{nullptr}; public: void push(const T& value) { Node* new_node = new Node(value); 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)) { // 使用更新后的 head 重试 } } bool pop(T& result) { Node* old_head = head_.load(std::memory_order_relaxed); while (old_head && !head_.compare_exchange_weak(old_head, old_head->next, std::memory_order_acquire, std::memory_order_relaxed)) { // 重试 } if (old_head) { result = old_head->data; delete old_head; // 注意: 存在 ABA 问题 return true; } return false; } }; // 无锁队列 (单生产者，单消费者) template class SPSCQueue { std::array buffer_; alignas(64) std::atomic he