线程安全-栈

当入栈获得锁时，必须从用户态转移到内核态，锁住互斥锁，再到达用户态继续向下运行。在入栈时，出栈函数由于获取不到锁，就会阻塞，直到入栈函数执行完释放锁之后才能在内核态获得锁，再转移到用户态继续执行。
同步：同步的意思是函数执行有顺序，A执行完之后才能执行B，B执行完之后才能执行C，以此类推。而不是简单的理解为同步就是同时执行
异步：异步指的是在同一时间内，A B C函数可能同时执行，没有固定的顺序，互相不影响。
完整代码：

//栈空异常类型，主要为栈空做准备
struct empty_stack :std::exception
//如果栈空，直接给出一个异常，exceotion是系统给出的一个异常类型，直接继承过来
{
	const char* what()const throw()//是什么原因导致异常
	{
		return "empty stack!";
	}
};
template<class T=int>
class threadsafe_stack
{
public:
	thraedsafe_stack(){}
	~threadsafe_stack(){}
	threadsafe_satck(const threadsafe_stack& other)
	{
		std::lock_guard<std::mutex>lock(other.m);
		data = other.data;
	}
	threadsafe_stack& operator=(const threadsafe_stack&) = delete;
	void empty()const
	{
		std::lock_guard<std::mutex>lock(m);
		return data.empty();
	}
	int GetSize()const
	{
		if (data.empty())throw empty_stack();//如果栈为空，就直接抛出异常
		return data.size();
	}
	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;
	}
	bool pop(T& val)
	{
		std::lock_guard<std::mutex>lock(m);
		if (data.empty())throw empty_stack();
		val = data.top();
		data.pop();
		return true;
	}
	void push(const T& val) 
	{
		std::lock_guard<std::mutex>lock(m);
		data.push(val);
	}
private:
	std::stack<T>data;
	mutable std::mutex m;//可变的互斥量
};

这个栈的效率太低，因为它每一次获得锁都需要用户态与内核态之间的转换
为了解决这个问题，我们可以使用原子操作，原子操作不需要用户态与内核态之间的转换，从而能大大提高效率。

void push(const Type& val)
	{//原子操作只在用户态执行，不会进行切换，执行效率非常高，可能插入的顺序会乱，但不会造成数据的丢失
		StackNode* newnode = Buynode(val);
		do
		{
			newnode->next = pHead.load();
		} while (!pHead.compare_exchange_strong(newnode->next, newnode));
	}

完整代码：

//栈空异常类型，主要为栈空做准备
struct empty_stack :std::exception
//如果栈空，直接给出一个异常，exceotion是系统给出的一个异常类型，直接继承过来
{
	const char* what()const throw()//是什么原因导致异常
	{
		return "empty stack!";
	}
};
//无锁链栈
template<class Type>
class UnLock_LinkStack
{
private:
	struct StackNode
	{
		Type data;
		StackNode* next;
		//调用缺省的构造，构造一个Type的类型，对val进行初始化，相当于有一个默认值
		//可以用0代替吗？不可以，如果Type是一个int类型，那么是是可以的，但如果Type是一个string类型，那就不行
		StackNode(const Type& val = Type(), StackNode* nt = NULL) :data(val), next(nt)
		{}
	};
private:
	std::atomic<int>count;//用原子 套进去
	std::atomic<StackNode*>pHead;
	static StackNode* Buynode(const Type& val)
	{
		return new StackNode<Type>(val);
	}
	static void Freenode(StackNode* p)
	{
		delete p;
	}
public:
	//原子的初始化，可以保证在初始化的过程中，不会被打断
	UnLock_LinkStack() :count(ATOMIC_VAR_INIT(0)), pHead(ATOMIC_VAR_INIT(NULL)) {}
	~UnLock_LinkStack() {};
	void push(const Type& val)
	{//原子操作只在用户态执行，不会进行切换，执行效率非常高，可能插入的顺序会乱，但不会造成数据的丢失
		StackNode* newnode = Buynode(val);
		do
		{
			newnode->next = pHead.load();
		} while (!pHead.compare_exchange_strong(newnode->next, newnode));
	}
	int size()const
	{
		return count.load();//原子的返回数值
	}
	bool empty()const
	{
		return count == 0;
	}
};
UnLock_LinkStack<int>ist;
//对于ist,当多线程共享使用时，就必须在线程函数传入引用，线程内对ist的改变就是ist本身
//如果线程函数不传入引用的话，线程内对ist的改变就是对副本的改变，不会影响到ist本身
void funa(UnLock_LinkStack<int>& ist)
{
	ist.push(23);
}
void funb(UnLock_LinkStack<int>& ist)
{
	ist.push(34);
}
int main()
{
	UnLock_LinkStack<int>ist;
	thread tha(funa, std::ref(ist));
	thread thb(funb, std::ref(ist));
	return 0;
}