对于互斥锁我们要先知道为什么要用互斥锁？它能解决什么问题？
根据这两个问题，可以来举个例子说明一下，假如现在我们要求1-10000的和，然后我们为了提高效率，我们建立两个线程同时去计算[1,5000)的和以及[5000,10001)的和，那么用于计算和的变量都用相同的ans来获取结果，代码如下：
代码语言：javascript复制#include <iostream>
#include <thread>
void work1(int& sum) {
for (int i = 1; i < 5000; i ) {
sum = i;
}
}
void work2(int& sum) {
for (int i = 5000; i <= 10000; i ) {
sum = i;
}
}
int fun() {
int sum = 0;
for (int i = 1; i <= 10000; i ) {
sum = i;
}
return sum;
}
int main()
{
int ans = 0;
std::thread t1(work1, std::ref(ans));
std::thread t2(work2, std::ref(ans));
t1.join();
t2.join();
std::cout << "sum1 : " << ans << std::endl;
std::cout << "sum2 : " << fun() << std::endl;
return 0;
}为了区别多线程的计算结果，我用fun函数求的结果与其作比较，然后运行的结果如下图所示：
我们发现两次的运算结果并不相同，那么我们可以分析一下原因，因为在计算过程中的sum是一个引用，是他们的共享资源，所以当一个线程正在计算 i的时候，此时还没有运算结束，就被切到了另一个线程中，然后在这个线程中可能会计算了很多次 i的操作，然后再切回那个线程中时，计算结果可能就会覆盖掉另一个线程的计算结果，因此这样求出来的数一定是比正确结果要小的，所以为了避免这种情况的发生，引入了互斥锁。
互斥锁的重点在于他是一个锁，简单来说就是我们用锁将两个线程中计算过程分别用mutex锁上，那么当一个线程正在计算的时候，另一个线程就会等待这个计算的完成。大致流程是这样的，当work1准备计算sum =i的时候，用mutex将线程其锁上，如果此时sum =i还没有计算完就切到了work2的线程时，就会通过mutex检测到已经被锁上了，那么work2就会在此等待work1的计算完成，当work1的计算完成以后就会把锁解开，然后进行下一步的计算。所以两个线程种的计算过程都是加锁-计算-解锁的过程，这样就不会出现上述所说的那种情况了。
互斥锁的实现过程很简单，mutex是一个类，首先我们要先创建出类对象std::mutex mylock，然后在你需要锁的代码块前后加上mylock.lock()和mylock.unlock()，就可以实现互斥锁的加锁和解锁了。可以具体实现可以看下面的代码：
代码语言：javascript复制#include <iostream>
#include <thread>
#include <mutex>
void work1(int& sum, std::mutex& mylock) {
for (int i = 1; i < 5000; i ) {
mylock.lock();
sum = i;
mylock.unlock();
}
}
void work2(int& sum, std::mutex& mylock) {
for (int i = 5000; i <= 10000; i ) {
mylock.lock();
sum = i;
mylock.unlock();
}
}
int fun() {
int sum = 0;
for (int i = 1; i <= 10000; i ) {
sum = i;
}
return sum;
}
int main()
{
std::mutex mylock;
int ans = 0;
std::thread t1(work1, std::ref(ans), std::ref(mylock));
std::thread t2(work2, std::ref(ans), std::ref(mylock));
t1.join();
t2.join();
std::cout << "sum1 : " << ans << std::endl;
std::cout << "sum2 : " << fun() << std::endl;
return 0;
}这是第一种互斥锁的实现方法。还有一种是用lock_guard类模板，它的内部结构很简单，只有构造函数和析构函数，所以也很容里理解它的工作原理，在实例化对象时通过构造函数实现了lock，在析构函数中实现了unlock的操作。这样就可以避免忘记unlock的情况，具体的实现看下面的代码：
代码语言：javascript复制#include <iostream>
#include <thread>
#include <mutex>
void work1(int& sum, std::mutex& mylock) {
for (int i = 1; i < 5000; i ) {
std::lock_guard<std::mutex> mylock_guard(mylock);
sum = i;
}
}
void work2(int& sum, std::mutex& mylock) {
for (int i = 5000; i <= 10000; i ) {
std::lock_guard<std::mutex> mylock_guard(mylock);
sum = i;
}
}
int fun() {
int sum = 0;
for (int i = 1; i <= 10000; i ) {
sum = i;
}
return sum;
}
int main()
{
std::mutex mylock;
int ans = 0;
std::thread t1(work1, std::ref(ans), std::ref(mylock));
std::thread t2(work2, std::ref(ans), std::ref(mylock));
t1.join();
t2.join();
std::cout << "sum1 : " << ans << std::endl;
std::cout << "sum2 : " << fun() << std::endl;
return 0;
}这样就在每次循环一次后会自动的构建互斥锁对象，循环完了就会析构掉这个互斥锁。当然为了使用的更灵活方便，我们可以通过大括号来规定实现的范围。比如下面这样：
代码语言：javascript复制 {
std::lock_guard<std::mutex> mylockguard(mylock);
/*...
中间用来写需要加锁的内容
*/
}
