基于锁的线程安全栈

序列化：多个线程轮流访问被互斥元保护的数据结构，他们必须线性地并且非并发地存取数据。设计时候要考虑使用更小的别保护区域和更少的操作被序列化，以及更高的并发潜能。
使得数据结构线程安全的基本原理：

• 保证当数据结构不变性被别的线程破坏时的状态不被任何别的线程看到。
• 注意避免数据结构接口所固有的竞争现象，通过为完整操作提供函数，而不是提供操作步骤。
• 注意当出现例外时，数据结构是怎样来保证不变性不被破坏的。
• 当使用数据结构时，通过限制锁的范围和避免使用嵌套锁，来降低产生死锁的机会。
  设计时候，尽量减少所的使用时间，数据在互斥锁保护区域外不会被访问，

#include <iostream>
#include <exception>
#include <thread>
#include <mutex>
#include  <memory>
#include <stack>
#include <utility>
using namespace std;
struct empty_stack: exception //标准异常类的基类
{
    const char* what() const throw();
};
template<typename T>
class tsafe_stack {
private:
    stack<T> data;
    mutable mutex m; //被mutable修饰的变量，将永远处于可变的状态
public:
    tsafe_stack(){};
    tsafe_stack(const tsafe_stack& obj) {
        lock_guard<mutex> lock(obj.m);//将被拷贝的对象锁定
        data = obj.data;
    }//拷贝构造
    tsafe_stack& operator=(const tsafe_stack&) = delete;// 禁止使用编译器默认生成的函数
    void push(T a_value) {
        lock_guard<mutex> lock(m);
        data.push(a_value);
    }
    shared_ptr<T> pop() {//pop重载第一种形式
        lock_guard<mutex> lock(m);
        if (data.empty()) {
            throw empty_stack();
        }
        shared_ptr<T> const res(
            shared_ptr<T>(move(data.top())));
        data.pop();
        return res;
    }
    void pop(T& v) {
        lock_guard<mutex> lock(m);
        if (data.empty()) {
            throw empty_stack();
        }
        v = move(data.top());
        data.pop();
    }
    bool empty()const {
        lock_guard<mutex> lock(m);
        return data.empty();
    }
};
int main()
{

    return  0;
}