C++第四十六弹---解锁多线程编程的奥秘：＜thread＞库深入探索

 ✨个人主页： 熬夜学编程的小林

💗系列专栏： 【C语言详解】 【数据结构详解】【C++详解】

目次

1 线程库
1.1 thread类的简单先容
1.2 线程函数参数
1.3 原子性利用库(atomic)
1.4 lock_guard与unique_lock
1.4.1 mutex的种类
1.4.2 lock_guard
1.4.3 unique_lock
1.5 支持两个线程瓜代打印，一个打印奇数，一个打印偶数

---

1 线程库


1.1 thread类的简单先容


在C++11之前，涉及到多线程题目，都是平静台相干的，好比windows和linux下各有本身的接口，这使得代码的可移植性比力差。C++11中最紧张的特性就是对线程举行支持了，使得C++在并行编程时不必要依靠第三方库，而且在原子利用中还引入了原子类的概念。要利用尺度库中的线程，必须包罗< thread >头文件。
C++11 线程类

https://cplusplus.com/reference/thread/thread/
函数名功能thread()构造一个线程对象，没有关联任何线程函数，即没有启动任何线程thread(fn,
args1, args2,
...)构造一个线程对象，并关联线程函数fn，args1，args2，...为线程函数的
参数get_id()获取线程idjoinable()线程是否还在实验，joinable代表的是一个正在实验中的线程。join()该函数调用后会壅闭住线程，当该线程竣过后，主线程继承实验detach()在创建线程对象后立刻调用，用于把被创建线程与线程对象分离开，分离
的线程变为背景线程，创建的线程的"死活"就与主线程无关留意：
1. 线程是利用体系中的一个概念，线程对象可以关联一个线程，用来控制线程以及获取线程的
状态。
2. 当创建一个线程对象后，没有提供线程函数，该对象实际没有对应任何线程。
代码演示

1. #include<iostream>
2. #include<thread>
3. using namespace std;
5. int main()
6. {
7.         std::thread t1;
8.         cout << t1.get_id() << endl;
9.         return 0;
10. }

复制代码

运行结果 

get_id()的返回值范例为id范例，id范例实际为std::thread定名空间下封装的一个类，该类中包罗了一个结构体：

1. // vs下查看
2. typedef struct
3. {
4.     /* thread identifier for Win32 */
5.     void *_Hnd; /* Win32 HANDLE */
6.     unsigned int _Id;
7. } _Thrd_imp_t;

复制代码

3. 当创建一个线程对象后，而且给线程关联线程函数，该线程就被启动，与主线程一起运行。
线程函数一样平常环境下可按照以下三种方式提供：

• 函数指针
  
• lambda表达式
  
• 函数对象
  

代码演示

1. #include<iostream>
2. #include<thread>
3. using namespace std;
5. void ThreadFunc(int a)
6. {
7.         cout << "Thread1->" << a << endl;
8. }
9. class TF
10. {
11. public:
12.         void operator()()
13.         {
14.                 cout << "Thread3" << endl;
15.         }
16. };
17. int main()
18. {
19.         // 线程函数为函数指针
20.         thread t1(ThreadFunc, 10);
22.         // 线程函数为lambda表达式
23.         thread t2([] {cout << "Thread2" << endl; });
25.         // 线程函数为函数对象
26.         TF tf;
27.         thread t3(tf);
29.         t1.join();// 阻塞线程
30.         t2.join();
31.         t3.join();
32.         cout << "Main thread!" << endl;
33.         return 0;
34. }

复制代码

运行结果 

4. thread类是防拷贝的，不允许拷贝构造以及赋值，但是可以移动构造和移动赋值，即将一个线程对象关联线程的状态转移给其他线程对象，转移期间不意向线程的实验。
5. 可以通过joinable()函数判断线程是否是有效的，如果是以下恣意环境，则线程无效 

• 接纳无参构造函数构造的线程对象
  
• 线程对象的状态已经转移给其他线程对象
  
• 线程已经调用join大概detach竣事
  

1.2 线程函数参数


线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，因此：纵然线程参数为引用范例，在
线程中修改后也不能修改外部实参，由于着实际引用的是线程栈中的拷贝，而不是外部实参。
代码演示 

1. #include<iostream>
2. #include<thread>
3. using namespace std;
4. void ThreadFunc1(int& x)
5. {
6.         x += 10;
7. }
8. void ThreadFunc2(int* x)
9. {
10.         *x += 10;
11. }
12. int main()
13. {
14.         int a = 10;
15.         // 在线程函数中对a修改，不会影响外部实参
16.         // 因为：线程函数参数虽然是引用方式，但其实际引用的是线程栈中的拷贝
17.         // vs 2022中必须显示传引用std::ref才行
18.         //thread t1(ThreadFunc1, a);
19.         //t1.join();
20.         cout << a << endl;
21.        
22.         // 如果想要通过形参改变外部实参时，必须借助std::ref()函数
23.         thread t2(ThreadFunc1, std::ref(a));
24.         t2.join();
25.         cout << a << endl;
26.         // 地址的拷贝
27.         thread t3(ThreadFunc2, &a);
28.         t3.join();
29.         cout << a << endl;
30.         return 0;
31. }

复制代码

运行结果 

留意：如果是类成员函数作为线程参数时，必须将this作为线程函数参数。
1.3 原子性利用库(atomic)


多线程最紧张的题目是共享数据带来的题目(即线程安全)。如果共享数据都是只读的，那么没题目，由于只读利用不会影响到数据，更不会涉及对数据的修改，以是全部线程都会得到同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜伏的贫苦。好比：
代码演示

1. #include<iostream>
2. #include<thread>
3. using namespace std;
4. unsigned long sum = 0L;
5. void fun(size_t num)
6. {
7.         for (size_t i = 0; i < num; ++i)
8.                 sum++;
9. }
10. int main()
11. {
12.         cout << "Before joining,sum = " << sum << std::endl;
13.         thread t1(fun, 10000000);
14.         thread t2(fun, 10000000);
15.         t1.join();
16.         t2.join();
17.         cout << "After joining,sum = " << sum << std::endl;
18.         return 0;
19. }

复制代码

运行结果 

C++98中传统的办理方式：可以对共享修改的数据可以加锁掩护。
代码演示

1. #include<iostream>
2. #include<thread>
3. #include<mutex>
4. using namespace std;
6. mutex mtx;// 头文件#include<mutex>
7. unsigned long sum = 0L;
8. void fun(size_t num)
9. {
10.         mtx.lock();// 上锁
11.         for (size_t i = 0; i < num; ++i)
12.         {
13.                 sum++;
14.         }
15.         mtx.unlock();// 解锁
16. }
17. int main()
18. {
19.         cout << "Before joining,sum = " << sum << std::endl;
20.         thread t1(fun, 10000000);
21.         thread t2(fun, 10000000);
22.         t1.join();
23.         t2.join();
24.         cout << "After joining,sum = " << sum << std::endl;
25.         return 0;
26. }

复制代码

运行结果 

固然加锁可以办理，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻
塞，会影响步调运行的服从，而且锁如果控制不好，还容易造成死锁。

因此C++11中引入了原子利用。所谓原子利用：即不可被停止的一个或一系列利用，C++11引入
的原子利用范例，使得线程间数据的同步变得非常高效。

 留意：必要利用以上原子利用变量时，必须添加头文件<atomic>
代码演示

1. #include<iostream>
2. #include<thread>
3. #include<atomic>
4. using namespace std;
6. atomic_long sum{ 0 };// 原子操作变量
7. void fun(size_t num)
8. {
9.         for (size_t i = 0; i < num; ++i)
10.                 sum++;        // 原子操作
11. }
12. int main()
13. {
14.         cout << "Before joining, sum = " << sum << std::endl;
15.         thread t1(fun, 1000000);
16.         thread t2(fun, 1000000);
17.         t1.join();
18.         t2.join();
19.         cout << "After joining, sum = " << sum << std::endl;
20.         return 0;
21. }

复制代码

运行结果 

在C++11中，步调员不必要对原子范例变量举行加锁解锁利用，线程可以大概对原子范例变量互斥的
访问。更为广泛的，步调员可以利用atomic类模板，界说出必要的恣意原子范例。 

1. atmoic<T> t;    // 声明一个类型为T的原子类型变量t

复制代码

留意：原子范例通常属于"资源型"数据，多个线程只能访问单个原子范例的拷贝，因此在C++11
中，原子范例只能从其模板参数中举行构造，不允许原子范例举行拷贝构造、移动构造以及
operator=等，为了防止不测，尺度库已经将atmoic模板类中的拷贝构造、移动构造、赋值运算
符重载默认删撤消了。

1. #include<iostream>
2. #include<atomic>
3. using namespace std;
4. int main()
5. {
6.         atomic<int> a1(0);
7.         //atomic<int> a2(a1);    // 拷贝构造编译失败
8.         atomic<int> a2(0);
9.         //a2 = a1;               // 赋值重载编译失败
10.         return 0;
11. }

复制代码

1.4 lock_guard与unique_lock


在多线程环境下，如果想要包管某个变量的安全性，只要将其设置成对应的原子范例即可，即高效又不容易出现死锁题目。但是有些环境下，我们大概必要包管一段代码的安全性，那么就只能通过锁的方式来举行控制。
好比：一个线程对变量number举行加一100次，别的一个减一100次，每次利用加一大概减一之
后，输出number的结果，要求：number末了的值为0。
代码演示

1. #include<iostream>
2. #include<thread>
3. using namespace std;
4. int number = 0;
5. mutex g_lock;
6. int ThreadProc1()
7. {
8.         g_lock.lock();
9.         for (int i = 0; i < 100; i++)
10.         {
11.                 ++number;
12.                 cout << "thread 1 :" << number << endl;
13.         }
14.         g_lock.unlock();
15.         return 0;
16. }
17. int ThreadProc2()
18. {
19.         g_lock.lock();
20.         for (int i = 0; i < 100; i++)
21.         {
22.                 --number;
23.                 cout << "thread 2 :" << number << endl;
24.         }
25.         g_lock.unlock();
26.         return 0;
27. }
28. int main()
29. {
30.         thread t1(ThreadProc1);
31.         thread t2(ThreadProc2);
32.         t1.join();
33.         t2.join();
34.         cout << "number:" << number << endl;
35.         system("pause");
36.         return 0;
37. }

复制代码

运行结果  

上述代码的缺陷：锁控制不好时，大概会造成死锁，最常见的好比在锁中心代码返回，大概在锁的范围内抛非常。因此：C++11接纳RAII的方式对锁举行了封装，即lock_guard和unique_lock。

1. class LockGuard
2. {
3. public:
4.         // 不支持拷贝构造，因此需要将成员变量设为引用变量
5.         // 构造上锁
6.         LockGuard(mutex& mtx)
7.                 :_mtx(mtx)
8.         {
9.                 _mtx.lock();
10.         }
11.         ~LockGuard()
12.         {
13.                 _mtx.unlock();
14.         }
15. private:
16.         mutex& _mtx;
17. };

复制代码

1.4.1 mutex的种类


在C++11中，Mutex统共包了四个互斥量的种类：

1. std::mutex
C++11提供的最根本的互斥量，该类的对象之间不能拷贝，也不能举行移动。mutex最常用的三个函数：
函数名函数功能lock()上锁：锁住互斥量unlock()解锁：开释对互斥量的全部权try_lock()实验锁住互斥量，如果互斥量被其他线程占据，则当火线程也不会被壅闭留意，线程函数调用lock()时，大概会发生以下三种环境：
如果该互斥量当前没有被锁住，则调用线程将该互斥量锁住，直到调用 unlock之前，

• 该线程不停拥有该锁
  
• 如果当前互斥量被其他线程锁住，则当前的调用线程被壅闭住
  
• 如果当前互斥量被当前调用线程锁住，则会产存亡锁(deadlock)
  

线程函数调用try_lock()时，大概会发生以下三种环境：

• 如果当前互斥量没有被其他线程占据，则该线程锁住互斥量，直到该线程调用 unlock开释互斥量
  
• 如果当前互斥量被其他线程锁住，则当前调用线程返回 false，而并不会被壅闭掉
  
• 如果当前互斥量被当前调用线程锁住，则会产存亡锁(deadlock)
  

2. std::recursive_mutex
其允许同一个线程对互斥量多次上锁（即递归上锁），来得到对互斥量对象的多层全部权，开释互斥量时必要调用与该锁条理深度雷同次数的 unlock()，除此之外，std::recursive_mutex 的特性和 std::mutex 大抵雷同。

3. std::timed_mutex
比 std::mutex 多了两个成员函数，try_lock_for()，try_lock_until() 。

• try_lock_for()
  

                担当一个时间范围，表如今这一段时间范围之内线程如果没有得到锁则被壅闭住（与std::mutex 的 try_lock() 差别，try_lock 如果被调用时没有得到锁则直接返回false），如果在此期间其他线程开释了锁，则该线程可以得到对互斥量的锁，如果超时（即在指定时间内照旧没有得到锁），则返回 false。

• try_lock_until()
  

                担当一个时间点作为参数，在指定时间点未到来之火线程如果没有得到锁则被壅闭住，如果在此期间其他线程开释了锁，则该线程可以得到对互斥量的锁，如果超时（即在指定时间内照旧没有得到锁），则返回 false。

4. std::recursive_timed_mutex
1.4.2 lock_guard


std::lock_gurad 是 C++11 中界说的模板类。界说如下：

1. template<class _Mutex>
2. class lock_guard
3. {
4. public:
5.         // 在构造lock_gard时，_Mtx还没有被上锁
6.         explicit lock_guard(_Mutex& _Mtx)
7.                 : _MyMutex(_Mtx)
8.         {
9.                 _MyMutex.lock();
10.         }
11.         // 在构造lock_gard时，_Mtx已经被上锁，此处不需要再上锁
12.         lock_guard(_Mutex& _Mtx, adopt_lock_t)
13.                 : _MyMutex(_Mtx)
14.         {}
15.         ~lock_guard() _NOEXCEPT
16.         {
17.                 _MyMutex.unlock();
18.         }
19.         lock_guard(const lock_guard&) = delete;
20.         lock_guard& operator=(const lock_guard&) = delete;
21. private:
22.         _Mutex& _MyMutex;
23. };

复制代码

通过上述代码可以看到，lock_guard类模板紧张是通过RAII的方式，对其管理的互斥量举行了封
装，在必要加锁的地方，只必要用上述先容的恣意互斥体实例化一个lock_guard，调用构造函数
乐成上锁，出作用域前，lock_guard对象要被烧毁，调用析构函数主动解锁，可以有效制止死锁
题目。
lock_guard的缺陷：太单一，用户没有办法对该锁举行控制，因此C++11又提供了unique_lock。
1.4.3 unique_lock

与lock_gard雷同，unique_lock类模板也是接纳RAII的方式对锁举行了封装，而且也是以独占全部权的方式管理mutex对象的上锁息争锁利用，即其对象之间不能发生拷贝。在构造(或移动(move)赋值)时，unique_lock 对象必要通报一个 Mutex 对象作为它的参数，新创建的unique_lock 对象负责传入的 Mutex 对象的上锁息争锁利用。利用以上范例互斥量实例化unique_lock的对象时，主动调用构造函数上锁，unique_lock对象烧毁时主动调用析构函数解锁，可以很方便的防止死锁题目。
与lock_guard差别的是，unique_lock更加的机动，提供了更多的成员函数：

• 上锁/解锁利用：lock、try_lock、try_lock_for、try_lock_until和unlock
  
• 修改利用：移动赋值、交换(swap：与另一个unique_lock对象交换所管理的互斥量全部权)、开释(release：返回它所管理的互斥量对象的指针，并开释全部权)
  
• 获取属性：owns_lock(返回当前对象是否上了锁)、operator bool()(与owns_lock()的功能雷同)、mutex(返回当前unique_lock所管理的互斥量的指针)。
  

1.5 支持两个线程瓜代打印，一个打印奇数，一个打印偶数


本节紧张演示了condition_variable的利用，condition_variable熟悉我们linux课程已经讲过了，他们用来举行线程之间的相互关照。condition_variable和Linux posix的条件变量并没有什么大的区别，紧张照旧面向对象实现的。
代码演示

1. #include<iostream>
2. #include<thread>
3. #include<mutex>
4. #include<condition_variable>
5. using namespace std;
7. // 两个线程交替打印，一个打印奇数，一个打印偶数
8. // [0 - n)
9. int main()
10. {
11.         mutex mtx;
12.         condition_variable c;
13.         int n = 100;
14.         bool flag = true;
16.         // 保证第一个打印的是0，不管是什么顺序
17.         thread t1([&]() {
18.                 int i = 0;
19.                 while (i < n)
20.                 {
21.                         unique_lock<mutex> lock(mtx);
22.                         // flag == true 不会阻塞
23.                         // flag == false 一直阻塞
24.                         while (!flag)
25.                                 c.wait(lock);
26.                        
27.                         cout << i << endl;
29.                         flag = false;
30.                         i += 2;
32.                         // 唤醒线程
33.                         c.notify_one();
34.                 }
35.                 });
36.         // 休眠1秒
37.         this_thread::sleep_for(std::chrono::milliseconds(1000));
39.         thread t2([&]() {
40.                 int j = 1;
41.                 while (j < n)
42.                 {
43.                         unique_lock<mutex> lock(mtx);
45.                         // flag == true 一直阻塞
46.                         // flag == false 不会阻塞
47.                         while (flag)
48.                                 c.wait(lock);
50.                         cout << j << endl;
52.                         flag = true;
53.                         j += 2;
55.                         // 唤醒线程
56.                         c.notify_one();
57.                 }
58.                 });
60.         t1.join();
61.         t2.join();
63.         return 0;
64. }

复制代码

运行结果 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金