C++ 高性能并发编程

// 原子类型基本用法
#include <atomic>
#include <thread>
#include <iostream>

std::atomic<int> counter(0);  // 初始化为0的原子整型

void increment_counter() {
    for (int i = 0; i < 1000; ++i) {
        counter++;  // 原子自增操作
    }
}

int main() {
    std::thread t1(increment_counter);
    std::thread t2(increment_counter);
    
    t1.join();
    t2.join();
    
    std::cout << "Counter value: " << counter.load() << std::endl;  // 总是输出2000
    return 0;
}

#include <atomic>
#include <thread>
#include <iostream>

std::atomic<bool> x, y;
std::atomic<int> z;

// 松散序示例 - 不保证操作顺序
void relaxed_example() {
    x.store(true, std::memory_order_relaxed);
    y.store(true, std::memory_order_relaxed);
}

// 获取-释放序示例 - 建立同步点
void release_example() {
    x.store(true, std::memory_order_relaxed);  // 1. 先设置x
    z.store(42, std::memory_order_release);    // 2. 释放z，确保x的写入可见
}

void acquire_example() {
    if (z.load(std::memory_order_acquire) == 42) {  // 3. 获取z
        // 如果z是42，那么x的写入在这里一定可见
        if (x.load(std::memory_order_relaxed)) {    // 4. 一定能看到x的变化
            // 这里会执行
        }
    }
}

// 顺序一致性示例 - 全局一致顺序
void sequential_example() {
    x.store(true, std::memory_order_seq_cst);  // 全局可见的写入
    y.store(true, std::memory_order_seq_cst);  // 全局可见的写入
}

// 无锁队列实现片段
#include <atomic>
#include <memory>

template<typename T>
class LockFreeQueue {
private:
    struct Node {
        std::shared_ptr<T> data;
        std::atomic<Node*> next;
        Node() : next(nullptr) {}
    };
    
    std::atomic<Node*> head;
    std::atomic<Node*> tail;

public:
    LockFreeQueue() {
        // 初始化一个哨兵节点
        Node* dummy = new Node;
        head.store(dummy);
        tail.store(dummy);
    }
    
    // 入队操作
    void enqueue(T value) {
        // 创建一个装有数据的新节点
        std::shared_ptr<T> new_data(std::make_shared<T>(std::move(value)));
        Node* new_node = new Node;
        new_node->data = new_data;
        
        // 获取当前尾指针
        Node* old_tail = tail.load();
        Node* nullptr_node = nullptr;
        
        // 循环直到成功将新节点链接到队列
        while (!old_tail->next.compare_exchange_weak(
            nullptr_node, new_node,
            std::memory_order_release,
            std::memory_order_relaxed)) {
            // 如果CAS失败，更新tail和重置nullptr_node
            old_tail = tail.load();
            nullptr_node = nullptr;
        }
        
        // 尝试更新尾指针
        tail.compare_exchange_strong(old_tail, new_node);
    }
    
    // 出队操作
    bool dequeue(T& result) {
        Node* old_head = head.load();
        
        // 循环直到成功弹出节点或队列为空
        while (old_head != tail.load()) {
            Node* next = old_head->next.load();
            if (next == nullptr) {
                // 队列为空
                return false;
            }
            
            // 尝试更新头指针
            if (head.compare_exchange_strong(old_head, next)) {
                // 成功更新头指针，取出值
                result = *(next->data);
                delete old_head;  // 释放旧的头节点
                return true;
            }
        }
        
        // 队列为空
        return false;
    }
    
    // 析构函数和其他必要方法省略...
};