本文共 3586 字，大约阅读时间需要 11 分钟。

目录

---

本文通过2个例子，来对多线程的资源竞争进行说明。

第1个是互斥范围。使用mutex等进行保护时，需要仔细选择保护的域的范围。范围选择太小，可能起不到线程互斥的作用。而范围太大，可能影响程序的执行效率和性能。

第2个是调用顺序。在一些场景下，即使采用了互斥机制，也不一定能确保线程安全，因为还需要考虑接口的调用顺序。

1.场景一(范围)

  下面例子使用vector实现了一个栈。两个线程轮流从中弹出元素。

#include 
   
    #include 
    
     #include 
     
      #include 
      
       #include 
       
        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
        
          data;};void Stack::pop(){ std::lock_guard
         
           guard(myMutex); data.erase(data.end()-1);}void Stack::push(int n){ std::lock_guard
          
            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
           
             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
   
     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 
   
    #include 
    
     using namespace std;template< typename T, typename Container = std::deque
     
       >class stack{public:	explicit stack(const Container&);	explicit stack(Container&& = Container());	template 
      
        explicit stack(const Alloc&);	template 
       
         stack(const Container&, const Alloc&);	template 
        
          stack(Container&&, const Alloc&); template 
         
           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
   
     s;if(!s.empty()){      int const value=s.top();      s.pop();      do_task(value);}
   

  但是，当stack instance共享时，对于一个空栈，调用top()可能导致未知的结果。调用顺序empty() -- > top() -- >pop()不再线程安全。empty()与top()之间，可能有另一个线程调用过了pop()。

  因此，这是一个接口调用顺序导致的竞争问题，而不是因为没有对底层资源进行保护产生的。那么，怎么解决呢？

  因为这是接口顺序导致的，因此方法就是修改这个接口。   最简单的方法，如果栈是空的则top()抛出一个异常。但是这会增加程序复杂性。