CPP多线程2：多线程竞争与死锁问题

在多线程编程中，多个线程协同工作能显著提升程序效率，但当它们需要共享和操作同一资源时，潜在的问题也随之而来；线程间的执行顺序不确定性可能导致资源竞争，可能引发死锁，让程序陷入停滞。

多线程竞争问题示例

我们现在已经知道如何在c++11中创建线程，那么如果多个线程需要操作同一个变量呢？

#include <iostream>
#include <thread>
using namespace std;
int n = 0;
void count10000() {for (int i = 1; i <= 10000; i++)n++;
}
int main() {thread th[100];for (thread &x : th)x = thread(count10000);for (thread &x : th)x.join();cout << n << endl;return 0;
}

可能的两次输出分别是：

991164
996417

我们的输出结果应该是1000000，可是为什么实际输出结果比1000000小呢？

在多线程的执行顺序——同时进行、无次序，所以这样就会导致一个问题：多个线程进行时，如果它们同时操作同一个变量，那么肯定会出错。为了应对这种情况，c++11中出现了std::atomic和std::mutex。

std::mutex

std::mutex是 C++11 中最基本的互斥量，一个线程将mutex锁住时，其它的线程就不能操作mutex，直到这个线程将mutex解锁。根据这个特性，我们可以修改一下上一个例子中的代码：

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;int n=0;
mutex mtx;
void count10000(){for(auto i=0;i<10000;i++){mtx.lock();n++;mtx.unlock();}
}
int main(){thread th[100];for (thread &x : th)x = thread(count10000);for (thread &x : th)x.join();cout<<n<<endl;return 0;
}

mutex的常用成员函数

std::lock_gard

使用mutex需要上锁解锁，但有时由于程序员忘记或者其他奇怪问题时，lock_gard可以自动解锁。其原理大概是构造时自动上锁，析构时自动解锁。示例如下：

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;int n=0;
mutex mtx;
void count100000(){for(auto i=0;i<100000;i++){lock_guard<mutex> lock1(mtx);n++;n--;}
}
int main(){thread th[10];for(int i=0;i<10;i++){th[i]=thread(count100000);}for(int i=0;i<10;i++){th[i].join();}cout<<n<<endl;return 0;
}

std::atomic

mutex很好地解决了多线程资源争抢的问题，但它也有缺点：太……慢……了……

比如前面我们定义了100个thread，每个thread要循环10000次，每次循环都要加锁、解锁，这样固然会浪费很多的时间，那么该怎么办呢？接下来就是atomic大展拳脚的时间了。

#include <iostream>
#include <atomic>
#include <thread>
using namespace std;atomic<int> n{0};// 列表初始化void count10000(){for(int i=0;i<10000;i++)n++;
}int main(){thread th[10];for(thread& x:th)x=thread(count10000);for(auto& x:th)x.join();cout<<n<<endl;return 0;
}

可以看到，我们只是改动了n的类型（int->std::atomic_int），其他的地方一点没动，输出却正常了。

atomic，本意为原子，可解释为：

原子操作是最小的且不可并行化的操作。

atomic常用成员函数

死锁问题

在多个线程中由于上锁顺序问题可能导致线程卡死，如下：

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;int n=0;
mutex mtx1;
mutex mtx2;
void count100000(){for(auto i=0;i<100000;i++){lock_guard<mutex> lock1(mtx1);lock_guard<mutex> lock2(mtx2);n++;n--;}
}
void count200000(){for(auto i=0;i<200000;i++){lock_guard<mutex> lock2(mtx2);lock_guard<mutex> lock1(mtx1);n++;n--;}
}
int main(){thread th[10];for(int i=0;i<10;i++){if(i%2==0)th[i]=thread(count100000);elseth[i]=thread(count200000);}for(int i=0;i<10;i++){th[i].join();}cout<<n<<endl;return 0;
}

这是因为在一个线程count100000中mtx1上锁后，另一个线程count200000也正好将mtx2上锁，于是这两个线程没办法获得另一个mutex，这就是死锁问题。

解决方法就是保持一样的上锁顺序，于是当一个线程A抢到第一个mutex时，其他线程无法再获得mutex，即只能线程A按着顺序处理完所有事物。示例如下：

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;int n=0;
mutex mtx1;
mutex mtx2;
void count100000(){for(auto i=0;i<100000;i++){lock_guard<mutex> lock1(mtx1);lock_guard<mutex> lock2(mtx2);n++;n--;}
}
void count200000(){for(auto i=0;i<200000;i++){lock_guard<mutex> lock1(mtx1);lock_guard<mutex> lock2(mtx2);n++;n--;}
}
int main(){thread th[10];for(int i=0;i<10;i++){if(i%2==0)th[i]=thread(count100000);elseth[i]=thread(count200000);}for(int i=0;i<10;i++){th[i].join();}cout<<n<<endl;return 0;
}