1. 接口设计1
下面例子使用vector实现了一个栈。两个线程轮流从中弹出元素。
#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <vector>
std::mutex myMutex;
class Stack
{
public:
Stack() {};
~Stack() {};
void pop();
int top() { return data.back(); }
void push(int);
void print();
int getSize() { return data.size(); }
private:
std::vector<int> data;
};
void Stack::pop()
{
std::lock_guard<std::mutex> guard(myMutex);
data.erase(data.end()-1);
}
void Stack::push(int n)
{
std::lock_guard<std::mutex> guard(myMutex);
data.push_back(n);
}
void Stack::print()
{
std::cout << "initial Stack : " ;
for(int item : data)
std::cout << item << " ";
std::cout << std::endl;
}
void process(int val, std::string s)
{
std::lock_guard<std::mutex> guard(myMutex);
std::cout << s << " : " << val << std::endl;
}
void thread_function(Stack& st, std::string s)
{
int val = st.top();
st.pop();
process(val, s);
}
int main()
{
Stack st;
for (int i = 0; i < 10; i++)
st.push(i);
st.print();
while(true) {
if(st.getSize() > 0) {
std::thread t1(&thread_function, std::ref(st), std::string("thread1"));
t1.join();
}
else
break;
if(st.getSize() > 0) {
std::thread t2(&thread_function, std::ref(st), std::string("thread2"));
t2.join();
}
else
break;
}
return 0;
}
运行后的结果之一：
initial Stack : 0 1 2 3 4 5 6 7 8 9
thread1 : 9
thread2 : 8
thread1 : 7
thread2 : 6
thread1 : 5
thread2 : 4
thread1 : 3
thread2 : 2
thread1 : 1
thread2 : 0
看上去这段代码是线程安全的。事实上并非如此。仍然有资源竞争存在，取决于执行的顺序。如下所示：
元素"6"可能被执行两次，且元素"5"被跳过了。
尽管从上面的运行结果看是正确的，但是代码中仍然存在可能触发资源竞争的条件。换言之，这段代码不是线程安全的。
一种解决方法是将函数top()与pop()合并到一个mutex下面：
int stack::pop()
{
lock_guard<mutex> guard(myMutex);
int val = data.back();
data.erase(data.end()-1);
return val;
}
void thread_function(stack& st, string s)
{
int val = st.pop();
process(val, s);
}
2. 接口设计2
假设需要处理一个双向链表list.
为了保证一个线程可以安全的从双向链表中删除一个node, 我们需要同时保证3个node的并发操作正确。即要删除的node,以及它前后的两个node. 如果我们对每个node都单独的进行保护，这跟不使用mutex没什么区别，因为竞争还是会发生。需要被包含的不是每个step中的单个node, 而是整个的删除操作。最简便的方法就是使用mutex保护整个list。
仅仅依靠单独的操作list来实现线程安全，我们还是没有达到目的。仍然可能存在竞争，即使使用的是一个很简单的接口。例如，下面的std::stack container adapter构成的栈数据结构。除了构造函数与swap()之外，还有5个函数是需要实现的。
push() - 插入新的元素入栈
pop() - 元素退栈
top() - 获取栈顶元素
empty() - 检测栈是否为空
size() - 元素个数
如果对top()函数进行修改，使得它返回的是一个拷贝，而不是引用，并且内部使用mutex来保护，这个接口仍然会存在竞争条件。问题不在于基于mutex来实现，而是这是一个接口问题，如果stack实现的是lock-free，则问题仍然存在。
#include <mutex>
#include <deque>
using namespace std;
template< typename T, typename Container = std::deque<T> >
class stack
{
public:
explicit stack(const Container&);
explicit stack(Container&& = Container());
template <typename Alloc> explicit stack(const Alloc&);
template <typename Alloc> stack(const Container&, const Alloc&);
template <typename Alloc> stack(Container&&, const Alloc&);
template <typename Alloc> stack(stack&&, const Alloc&);
// not reliable
bool empty() const;
// not reliable
size_t size() const;
T& top();
T const& top() const;
void push(T const&);
void push(T&&);
void pop();
void swap(stack&&);
};
此段代码的问题在与empty()与size()是不可靠的。在某个线程调用empty或size之前，其它线程可能已经调用了push或pop对栈进行了改变。
特别地，当一个stack instance不共享时，可以安全的调用empty()以及top()，如下：
stack<int> s;
if(!s.empty())
{
int const value=s.top();
s.pop();
do_task(value);
}
不过，当stack instance共享时，对于一个空栈，调用top()可能导致未知的结果。调用顺序empty() -- > top() -- >pop()不再线程安全。empty()与top()之间，可能有另一个线程调用过了pop().
因此，这是一个接口调用顺序导致的竞争问题，而不是因为没有对底层资源进行保护产生的。那么，怎么解决呢？
因为这是接口顺序导致的，因此方法就是修改这个接口。
最简单的方法，top()抛出一个异常，如果栈是空的。但是这会增加程序复杂性。
C++11线程指南(七)--资源竞争条件