C++多线程同步（上）

引言

项目中使用多线程，会遇到两种问题，一种是对共享资源的访问时需要考虑多线程竞争访问导致的不是预期的结果，另一种是多线程之间需要同步的问题。其实质归根结底就是多线程之间的同步。
本文主要在C++11的基础之上，结合示例讲述多线程同步的几种方法。
本文为上篇。

总述

C++中多线程同步的方式分为：
互斥锁，条件变量，读写锁，信号量，future和promise,原子操作，线程局部存储。

详情

下面根据上面提到的七种线程同步的方式分别给出示例。

互斥锁

互斥锁用于解决多线程间对共享资源的竞争问题，具有排它性。一旦一个线程获取锁，并加锁，其他的线程只能阻塞等待该线程解锁之后再抢占锁，且每次只能有一个线程获得锁，没有获得锁的线程只能阻塞等待。

示例

下面是互斥锁的示例：

#include 
#include 
#include 

using namespace std;
mutex g_mutex;

void fun(int n,const char& c) {
   
    g_mutex.lock();
    cout << "子线程的线程id:" <<this_thread::get_id()<<"开始执行该线程......"<< endl;
    
    for (int i = 0; i < n;++i) {
   
        cout << c;
    }
    cout << endl;
    cout << this_thread::get_id()<<"子线程结束" << endl;
    g_mutex.unlock();
}

int main()
{
   
    thread t1(fun,5,'S');
    thread t2(fun,6,'*');

    t1.join();
    t2.join();

    cout << "主线程的id：" << this_thread::get_id() << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

运行结果

分析

上面的示例创建了两个子线程，执行相同的线程处理函数，这就涉及到多线程对共享资源的竞争问题，这里两个子线程都抢着调用线程处理函数fun。由于何时加锁，在哪里加锁，需要结合开发人员的实际需求而定。这个示例希望程序能够输出完整的一个子线程调用fun函数后的内容，所以在刚进入线程处理函数和离开线程处理函数的时候进行加锁和解锁。

若是希望只给fun函数中的循环打印部分加锁，可以这样修改（只修改线程处理函数fun加锁，解锁位置，其它不变）：

void fun(int n,const char& c) {
   
    cout << "子线程的线程id:" <<this_thread::get_id()<<"开始执行该线程......"<< endl;
    g_mutex.lock();
    for (int i = 0; i < n;++i) {
   
        cout << c;
    }
    g_mutex.unlock();
    cout << endl;
    cout << this_thread::get_id()<<"子线程结束" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12

执行的结果：

可以看到上面的示例，变动了加锁和解锁的位置之后，很明显的出现了资源竞争，输出后结果出现了混乱。当然输出结果也会出现很多种，无法确定。像下面这样，是再次运行被修改加锁和解锁的位置之后的运行结果。

也可能是这样的运行结果：

对于加锁的部分，当前获取锁的子线程可以保证其连续执行，但是不加锁的部分就会出现资源竞争抢占，最终两个子线程的同一个线程处理函数fun中不加锁的内容会穿插着输出，达不到想要的效果。

条件变量

条件变量需要与互斥锁搭配使用来达到想要的效果。

示例一

实现

下面是实现代码：

#include 
#include 
#include 
#include 

using namespace std;
mutex g_mutex;
condition_variable g_cond;
bool IsReady = false;
const int g_num = 10;

void fun(int n) {
   
    unique_lock<mutex> lock(g_mutex);
    while (!IsReady) {
   
        cout << "线程被阻塞....." << endl;
        g_cond.wait(lock);
    }
    cout << "线程" <<this_thread::get_id()<<"执行完成！"<< endl;
}

void wakeUp() {
   
    this_thread::sleep_for(chrono::milliseconds(2));//延迟2毫秒，为了让子线程出现阻塞等待的过程
    unique_lock<mutex> lock(g_mutex);
    IsReady = true;
    cout <<
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27