一、什么是竞争条件?
在多线程环境中，线程间的数据共享很简单，但是在程序中这种简单的数据共享可能会引起问题，最常见的错误之一就是竞争条件(race condition)，而其中最常见的就是数据竞争(data race)。
竞争条件是发生在多线程应用程序中的一种 bug。当两个或多个线程并行执行一组操作，访问相同的内存位置，此时，它们中的一个或多个线程会修改内存位置中的数据，这可能会导致一些意外的结果，这就是竞争条件。
竞争条件通常较难发现并重现，因为它们并不总是出现，只有当两个或多个线程执行操作的相对顺序导致意外结果时，它们才会发生。
C++ 中常见的cout就是一个共享资源，如果在多个线程同时执行cout，你会发现很奇怪的问题：
#include <iostream>
#include <thread>
void threadTask()
{
for (int i = 0; i < 10; i++)
{
std::cout << "print thread: " << i << std::endl;
}
}
int main()
{
std::thread t(threadTask);
for (int i = 0; i > -10; i--)
{
std::cout << "print main: " << i << std::endl;
}
t.join();
return 0;
}
输出如下：
print main: 0
print main: -1
print main: -2
print main: -3
print main: -4
print main: -5
print main: print thread: 0
-6
print main: -7
print main: -8
print thread: 1
print thread: 2
print thread: 3
print thread: 4
print thread: 5
print thread: 6
print thread: 7
print thread: 8
print thread: 9
print main: -9
大家可以看到产生了一个很奇怪的现象，出现了print main: print thread: 0这样奇怪的打印结果。这是因为cout是基于流的，会先将你要打印的内容放入缓冲区，可能刚刚一个线程（主线程）刚刚放入print main:，另一个线程（t）就执行了，导致输出变乱。而 C 语言中的printf不会发生这个问题。
那么怎么解决这个问题呢？解决办法就是要对cout这个共享资源进行保护，以便我们在一个线程里处理完我们所需要的数据之后，然后才将控制权交出呢？这个就是用到锁这个东西。
假设线程 A 在执行cout << "print thread: " << i << endl;这个代码之前，在前面锁住一下，当线程 B 想来抢夺控制权的时候，发现这个地方（其实就是cout）已经被上锁了，无法抢夺，只能等待，等待它释放。执行完那个代码之后就可以释放锁，然后 B 线程就允许来抢夺控制权了，一旦 B 获得了控制权也给自己上了锁，防止在执行关键地方的时候被别人夺去控制权。那么 C++ 如何实现加锁的过程的呢？
二、使用互斥锁保护共享数据
在 C++ 中，可以使用互斥锁std::mutex进行资源保护，中文就是互斥量的意思，顾名思义，就是一个时刻只能有一个访问。头文件是#include <mutex>，共有两种操作：锁定(lock)与解锁(unlock)。将cout重新封装成一个线程安全的函数：
#include <iostream>
#include <thread>
#include <mutex>
// 实例化互斥锁对象，不要理解为定义变量
std::mutex g_mutex;
// 使用锁保护，创建一个线程安全的打印函数
void safePrint(std::string msg, int val) {
g_mutex.lock(); // 上锁
std::cout << msg << val << std::endl;
g_mutex.unlock(); // 解锁
}
void threadTask()
{
for (int i = 0; i < 10; i++)
safePrint("print thread: ", i);
}
int main()
{
std::thread t(threadTask);
for (int i = 0; i > -10; i--)
safePrint("print main: ", i);
t.join();
return 0;
}
输出如下：
print main: 0
print main: -1
print thread: 0
print thread: 1
print thread: 2
print thread: 3
print main: -2
print thread: 4
print main: -3
print thread: 5
print main: -4
print thread: 6
print main: -5
print main: -6
print thread: 7
print main: -7
print thread: 8
print main: -8
print thread: 9
print main: -9
在需要加锁的地方，调用g_mutex.lock()方法，解锁的地方调用g_mutex.unlock()方法，这样就将safePrint()变为了线程安全的函数了，也就能顺序的输出所需要的结果了。
三、为保护共享数据精心组织代码
前面的std::mutex互斥锁是个全局变量，他是为safePrint()准备的，这个时候，我们最好将他们绑定在一起，比如说，可以封装成一个类。由于cout是个全局共享的变量，没法完全封装，就算你封装了，外面还是能够使用cout，并且不用通过锁。所以下面换成文件流std::ofstream f来举例：
#include <iostream>
#include <thread>
#include <mutex>
#include <fstream>
class LogFile {
std::mutex m_mutex; // 互斥锁，设置为类成员遍历，而不是全局变量
std::ofstream f;
public:
LogFile() {
f.open("log.txt");
}
~LogFile() {
f.close();
}
void safePrint(std::string str, int val) {
std::lock_guard<std::mutex> guard(m_mutex);
f << str << val << std::endl;
}
};
void threadTask(LogFile& log) {
for (int i = 0; i > -10; i--)
log.safePrint("print thread: ", i);
}
int main()
{
LogFile log;
// 子线程
std::thread t1(threadTask, std::ref(log));
// 主线程
for (int i = 0; i < 10; i++)
log.safePrint("print main: ", i);
t1.join();
return 0;
}
上面的LogFile类封装了一个mutex和一个ofstream对象，然后safePrint函数在mutex的保护下，是线程安全的。使用的时候，先定义一个LogFile的实例log，主线程中直接使用，子线程中通过引用传递过去（也可以使用单例来实现），这样就能保证资源（ofstream 对象 f）被互斥锁保护着。
但是这个时候还是得小心了！用互斥锁保护数据并不只是像上面那样保护每个函数，就能够完全的保证线程安全，如果将资源的指针或者引用不小心传递出来了，所有的保护都白费了！要记住一下两点：
-
不要提供函数让用户获取资源。例如：
// Never return f to the outside world ofstream& getStream() { return f; } -
不要把资源作为参数传递给用户提供的函数。例如：
// Never pass f as an argument to user provided function void process(void fun(ostream&)) { fun(f); }
以上两种做法都会将资源暴露给用户，造成不必要的安全隐患。
四、接口设计中也存在竞争条件
STL 中的stack类是线程不安全的，于是你模仿着想写一个属于自己的线程安全的类Stack。于是，你在push和pop等操作的时候，加了互斥锁保护数据。但是在多线程环境下使用使用你的Stack类的时候，却仍然有可能是线程不安全的，why？
假设你的Stack类的接口如下：
class Stack
{
public:
Stack() {}
void pop(); // 弹出栈顶元素
int& top(); // 获取栈顶元素
void push(int x); // 将元素放入栈
private:
vector<int> data;
std::mutex _mu; //保护内部数据
};
类中的每一个函数都是线程安全的，但是组合起来却不是。加入栈中有9,3,8,6共4个元素，栈顶元素为 6，你想使用两个线程分别取出栈中的元素进行处理，如下所示：
// 处理函数
void process(int v) {
std::cout << "v: " << v << std::endl;
}
// 线程任务函数
void threadTask(Stack &st) {
int v = st.top();
st.pop();
process(v);
}
int main()
{
Stack stObj; // 默认有4个元素：9,3,8,6
std::thread threadA(threadTask, std::ref(stObj));
std::thread threadB(threadTask, std::ref(stObj));
threadA.join();
threadB.join();
return 0;
}
实际流程可能如下：
// threadA | // threadB
int v = st.top(); // 6 |
| int v = st.top(); // 6
st.pop(); // 弹出6 |
| st.pop(); // 弹出8
| process(v); // 处理6
process(v); // 处理6 |
可以发现在这种执行顺序下， 栈顶元素6被处理了两遍，而且多弹出了一个元素8，导致8没有被处理！这就是由于接口设计不当引起的竞争。解决办法就是将这两个接口top()和pop()合并为一个接口，即int &pop()，不再组合使用，就可以得到线程安全的栈。
class Stack
{
public:
Stack() {}
int& pop(); // 弹出栈顶元素并返回
void push(int x); // 将元素放入栈
private:
vector<int> data;
std::mutex _mu; // 保护内部数据
};
// 安全的线程任务函数
void threadTask(Stack &st) {
int v = st.pop();
process(v);
}
但是注意：这样修改之后是线程安全的，但是并不是异常安全的，这也是为什么 STL 中栈的出栈操作分解成了两个步骤的原因。（为什么不是异常安全的还没想明白。。）所以，为了保护共享数据，还得好好设计接口才行。
参考：