目录
本文通过2个例子,来对多线程的资源竞争进行说明。
第1个是互斥范围。使用mutex等进行保护时,需要仔细选择保护的域的范围。范围选择太小,可能起不到线程互斥的作用。而范围太大,可能影响程序的执行效率和性能。
第2个是调用顺序。在一些场景下,即使采用了互斥机制,也不一定能确保线程安全,因为还需要考虑接口的调用顺序。
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.场景二(顺序)
假设需要处理一个双向链表list.
为了保证一个线程可以安全的从双向链表中删除一个node, 我们需要同时保证3个node的并发操作正确。即要删除的node,以及它前后的两个node. 如果我们对每个node都单独的进行保护,这跟不使用mutex没什么区别,因为竞争还是会发生。
需要被保护的不是每个step中的单个node, 而是整个的删除操作。最简便的方法就是使用mutex保护整个list。
仅仅依靠单独的操作list来实现线程安全,我们还是没有达到目的,仍然可能存在竞争,即使使用的是一个很简单的接口。
例如,下面的std::stack container构成的栈数据结构。除了构造函数与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()抛出一个异常。但是这会增加程序复杂性。