线程安全的 stack

stack 不是一种容器， 而是一种适配器， 它的实现大概是这样的：

template<typename T, typename Container = deque<T> >

class stack

{

public:

    explicit  stack (const Container&);

    explicit  stack (Container&& = Container ());

    

    template<class Alloc> explicit stack (const Alloc&);

    template<class Alloc> stack (

        const Container&, const Alloc&);

    template<class Alloc> stack (Container&&, const Alloc&);

    template<class Alloc> stack (stack&&, const Alloc&);

    

    bool     empty () const;

    size_t   size () const;

    

    T&       top ();

    T const& top () const;

    

    void     push (T const&);

    void     push (T&&);

    void     pop ();

    void     swap (stack&&);

};

可是这个版本并不是线程安全的， 比如：

void oops ()

{

    stack<int> s;

    if (!s.empty()) {

        int const value = s.top ();

        s.pop ();

        //do_something (value);

    }

}

假设这么一种情况， 对于只有一个元素的 s，线程 A 和线程 B 当前都已执行了 if 中的判断， 此时线程 A 得到了 value 的值， 然后执行 pop()。 但是， 在这之后，执行了线程的切换， 此时线程 B 开始师徒试图给 value 赋值， 可早已人去楼空。

那么， 怎样才能在线程安全的前提下得到栈顶的值并在复制之后 pop 它呢？ 答案是这样：

template<typename Stack>

void empty_stack_check (const Stack& s)

{

    if (s.empty ()) {

        throw empty_stack ();

    }

}



struct empty_stack : std::exception

{

    const char* what () const throw();

};



template<typename T>

class thread_safe_stack

{

private:

    stack<T>      data;

    mutable mutex m;

public:

    using lockGuard = lock_guard<mutex>;

    thread_safe_stack () {}

    thread_safe_stack (const thread_safe_stack& other)

    {

        lockGuard lock (other.m);

        data = other.data;

    }



    stack& operator=(const thread_safe_stack&) = delete;



    void push (T new_value)

    {

        lockGuard lock (m);

        data.push (new_value);

    }



    shared_ptr<T> pop ()

    {

        lockGuard lock (m);

        empty_stack_check (data);



        shared_ptr<T> const res = 

            make_shared<T> (data.top());

        data.pop ();

        return res;

    }



    void pop (T& value)

    {

        lockGuard lock (m);

        empty_stack_check (data);

        value = data.top ();

        data.pop ();

    }



    bool empty () const

    {

        lockGuard lock (m);

        return data.empty ();

    }

};