实现线程安全的堆栈：解决多线程中的数据竞争问题

在多线程编程中，数据竞争是一个常见且棘手的问题。当多个线程同时访问共享数据时，如果没有适当的同步机制，就会导致未定义行为。本文将通过一个线程安全堆栈的实现，展示如何避免这类问题。

问题背景

标准库中的std::stack并不是线程安全的。如果多个线程同时调用push()和pop()操作，可能会导致数据竞争和不一致的状态。我们需要一个线程安全的替代方案。

线程安全堆栈设计

简化接口设计

template<typename T>
class threadsafe_stack
{
public:
    void push(T new_value);           // 向堆栈压入新元素
    std::shared_ptr<T> pop();         // 弹出堆栈顶部元素（返回智能指针）
    void pop(T& value);               // 弹出堆栈顶部元素（通过引用返回）
    bool empty() const;               // 检查堆栈是否为空
};

这个设计 deliberately 简化了接口，只提供必要的操作。赋值操作被明确删除，避免了潜在的线程安全问题。

使用互斥锁保护数据

private:
    std::stack<T> data;        // 内部使用的标准堆栈
    mutable std::mutex m;      // 可变互斥锁，用于保护数据访问

每个操作都使用std::lock_guard<std::mutex>来保证互斥访问，确保同一时间只有一个线程可以修改堆栈。

两种弹出方式

提供两种pop()方法满足了不同场景的需求：

• 返回std::shared_ptr<T>避免了异常安全问题
• 通过引用参数返回结果可能更高效

异常处理

// 空堆栈异常类
struct empty_stack: std::exception
{
    const char* what() const throw() {
        return "empty stack!";
    };
};

当尝试从空堆栈弹出元素时，会抛出empty_stack异常，这比返回特殊值或未定义行为更加安全。

完整实现代码

#include <exception>
#include <memory>   // 用于 std::shared_ptr<>
#include <mutex>    // 用于 std::mutex 和 std::lock_guard
#include <stack>    // 用于 std::stack<>

// 空堆栈异常类
struct empty_stack: std::exception
{
    const char* what() const throw() {
        return "empty stack!";
    };
};

// 线程安全堆栈模板类
template<typename T>
class threadsafe_stack
{
private:
    std::stack<T> data;        // 内部使用的标准堆栈
    mutable std::mutex m;      // 可变互斥锁，用于保护数据访问
  
public:
    // 默认构造函数
    threadsafe_stack()
        : data(std::stack<T>()){}
  
    // 拷贝构造函数
    threadsafe_stack(const threadsafe_stack& other)
    {
        std::lock_guard<std::mutex> lock(other.m); // 锁定源堆栈的互斥量
        data = other.data;                         // 执行数据拷贝
    }

    // 删除赋值运算符，避免潜在的线程安全问题
    threadsafe_stack& operator=(const threadsafe_stack&) = delete;

    // 向堆栈压入新元素
    void push(T new_value)
    {
        std::lock_guard<std::mutex> lock(m); // 锁定互斥量
        data.push(new_value);                // 执行压入操作
    }
  
    // 弹出堆栈顶部元素（返回智能指针版本）
    std::shared_ptr<T> pop()
    {
        std::lock_guard<std::mutex> lock(m); // 锁定互斥量
        if(data.empty()) throw empty_stack(); // 检查堆栈是否为空
        
        // 创建堆栈顶部元素的共享指针
        std::shared_ptr<T> const res(std::make_shared<T>(data.top()));
        data.pop(); // 移除堆栈顶部元素
        return res; // 返回结果
    }
  
    // 弹出堆栈顶部元素（通过引用参数返回版本）
    void pop(T& value)
    {
        std::lock_guard<std::mutex> lock(m); // 锁定互斥量
        if(data.empty()) throw empty_stack(); // 检查堆栈是否为空
        
        value = data.top(); // 将堆栈顶部元素赋值给引用参数
        data.pop();         // 移除堆栈顶部元素
    }
  
    // 检查堆栈是否为空
    bool empty() const
    {
        std::lock_guard<std::mutex> lock(m); // 锁定互斥量
        return data.empty();                 // 返回堆栈状态
    }
};

关键实现细节

构造函数中的线程安全

// 拷贝构造函数
threadsafe_stack(const threadsafe_stack& other)
{
    std::lock_guard<std::mutex> lock(other.m); // 锁定源堆栈的互斥量
    data = other.data;                         // 执行数据拷贝
}

拷贝构造函数也需要加锁，防止在拷贝过程中其他线程修改源堆栈。

使用std::shared_ptr避免内存管理问题

std::shared_ptr<T> const res(std::make_shared<T>(data.top()));

使用std::shared_ptr可以避免内存分配管理的问题，并避免多次使用new和delete操作。智能指针的使用确保了即使发生异常，资源也能被正确释放。

异常安全设计

if(data.empty()) throw empty_stack(); // 检查堆栈是否为空

在修改堆栈前先检查是否为空，确保操作的安全性。当堆栈为空时抛出异常，而不是返回特殊值，这使得错误处理更加明确。

使用示例

// 创建线程安全堆栈
threadsafe_stack<int> stack;

// 在多线程环境中使用
void producer() {
    for (int i = 0; i < 10; ++i) {
        stack.push(i); // 线程安全压入
    }
}

void consumer() {
    try {
        std::shared_ptr<int> value = stack.pop(); // 线程安全弹出
        // 处理value...
    } catch (const empty_stack& e) {
        // 处理空堆栈情况
        std::cout << e.what() << std::endl;
    }
}

总结

这个线程安全堆栈的实现展示了多线程编程中的几个重要概念：

1. 互斥锁的使用：通过std::mutex和std::lock_guard确保对共享数据的互斥访问
2. 接口简化：通过减少不必要的操作降低复杂度，提高安全性
3. 异常安全：合理使用异常和智能指针确保资源正确释放
4. 拷贝控制：删除赋值运算符，避免潜在的线程安全问题

这种实现方式虽然简单，但提供了基本的线程安全保障。在实际应用中，可能需要根据具体需求进行扩展或优化，例如使用更高效的锁机制或实现无锁数据结构。