• C++ 11：多线程相关问题

    目录

    一. 线程类thread

    1.1 thread的一些接口函数

    2.2 通过thread创建多线程

    二. this_thread

    三. 互斥锁与原子操作

    3.1 多线程中的加锁与解锁

    3.1.1 mutex类

    3.1.2 lock_guard 类

    3.3 原子性操作

    四. 条件变量

    4.1 线程互斥的缺陷

    4.2 condition_variable 实现线程同步

    五. 单例模式的线程安全问题

    5.1 饿汉模式的线程安全问题

    5.2 懒汉模式的线程安全问题

    六. 智能指针的线程安全问题

    七. 总结

    一. 线程类thread

    1.1 thread的一些接口函数

    接口函数实现功能
    thread() noexcept默认构造函数，创建空线程

    template

    thread thread(Fn&& fn, Args&& ...args)

    		通过指定函数和传给函数的参数，来创建线程，其中fn为线程函数，fn的返回类型应为void，如果希望向线程函数中传递引用x，应当使用std::ref(x)来传参。
    thread(thread&& th)移动构造函数（线程类thread禁止拷贝构造）
    thread& operator=(thread&& th)移动赋值函数（线程类thread禁止拷贝赋值）
    void join()阻塞等待线程
    void detach()分离线程

    代码1.1通过创建子线程的方式，使用线程函数对main函数作用域中的变量count进行100次++操作，join线程后输出此时count的值。注意，要在线程函数内部控制外部的变量，就要传引用，而向线程函数串引用必须通过std::ref()传参。

    运行代码输出结果为count = 100，表明引用传参成功。

    代码1.1：创建线程并向线程函数传递引用类型参数

    1. #include <iostream>
    2. #include <thread>
    3.  
    4. void add(int& x)
    5. {
    6. 	for (int i = 0; i < 100; ++i)
    7. 	{
    8. 		++x;
    9. 	}
    10. }
    11.  
    12. int main()
    13. {
    14. 	int count = 0;
    15. 	// 创建线程，线程函数为add
    16. 	// std::ref(add)传递引用
    17. 	std::thread th(add, std::ref(count));
    18.  
    19. 	th.join();
    20. 	std::cout << "count = " << count << std::endl;
    21.  
    22. 	return 0;
    23. }

    如代码1.2所示，我们还可以将线程函数以lambda表达式的格式来传递，lambda表达式可以很方便的以值或引用的方式捕捉父作用域的变量。

    代码1.2：以lambda表达式的方式传递线程函数

    1. #include <iostream>
    2. #include <thread>
    3.  
    4. int main()
    5. {
    6. 	int count = 0;
    7. 	
    8. 	std::thread th([&]() {
    9. 		for(int i = 0; i < 100; ++i)
    10. 		{
    11. 			++count;
    12. 		}
    13. 	});
    14.  
    15. 	th.join();
    16. 	std::cout << "count = " << count << std::endl;
    17.  
    18. 	return 0;
    19. }

    2.2 通过thread创建多线程

    只要在主线程中，通过thread构造函数创建多个线程类对象，并且执行特定的线程函数，就能够创建出多线程场景，为了方便控制，我们先创建std::vector，让vector先存储一些列由默认构造函数创建出来的thread类对象，然后通过for循环移动赋值，来让thread运行起特定的线程函数。代码2.3通过thread创建了4个子线程，并通过vector存储和管理每个thread对象。

    注意：thread对象只能支持移动赋值，不支持拷贝赋值！

    代码2.3：通过thread类创建多线程

    1. #include <iostream>
    2. #include <thread>
    3. #include <string>
    4. #include <vector>
    5. #include <Windows.h>
    6.  
    7. const int g_thread_num = 4;   // 子线程数
    8.  
    9. // 线程函数
    10. void threadRoutine(std::string name)
    11. {
    12. 	while (true)
    13. 	{
    14. 		std::cout << name << std::endl;
    15. 		Sleep(1);
    16. 	}
    17. }
    18.  
    19. int main()
    20. {
    21. 	std::vector<std::thread> vth(4);
    22. 	
    23. 	// 通过移动赋值创建子线程，执行threadRoutine函数
    24. 	for (int i = 0; i < g_thread_num; ++i)
    25. 	{
    26. 		std::string name("Thread ");
    27. 		name += std::to_string(i + 1);
    28. 		vth[i] = std::thread(threadRoutine, name);   // 移动赋值
    29. 	}
    30.  
    31. 	// 线程等待
    32. 	for (int i = 0; i < g_thread_num; ++i)
    33. 	{
    34. 		vth[i].join();
    35. 	}
    36.  
    37. 	return 0;
    38. }

    二. this_thread

    C++标准库内定义命名空间std::this_thread，表2.1为其中包含的四个多线程相关的函数。

    函数名称函数功能
    void yield() noexcept让出时间片，CPU资源让给其他线程
    thread::id get_id()获取当前线程的线程id

    void sleep_for(chrono::duration& real_time)

    		线程休眠特定时间
    void sleep_until(chrono::time_points& abs_time)线程休眠到指定时间

    一般来说，极少使用sleep_until，而是使用sleep_for，sleep_for可以指定休眠时长的单位为：小时、分钟、秒、微秒、毫秒、纳秒等，图2.1为sleep_for支持的时长单位，代码2.1中演示了yield、sleep_for和get_id的使用方法。

    图2.1 sleep_for支持的时间单位

    代码2.1：对this_thread中定义的函数的使用

    1. #include <iostream>
    2. #include <thread>
    3. #include <Windows.h>
    4.  
    5. int main()
    6. {
    7. 	bool ready = false;
    8.  
    9. 	std::thread th([&ready]() {
    10. 		// ready为false，该线程就让出时间片
    11. 		while (!ready)
    12. 		{
    13. 			std::this_thread::yield();
    14. 		}
    15. 		std::cout << "线程开始执行" << std::endl;
    16.  
    17. 		// 线程休眠0.5秒（500微秒）
    18. 		std::this_thread::sleep_for(std::chrono::milliseconds(500));
    19.  
    20. 		// 打印线程id
    21. 		std::cout << "Thread id: " << std::this_thread::get_id() << std::endl;
    22. 	});
    23.  
    24. 	// 主线程先执行3秒，然后才更改ready为true，运行线程th获取时间片
    25. 	for (int i = 0; i < 3; ++i)
    26. 	{
    27. 		std::cout << "main thread" << std::endl;
    28. 		Sleep(1000);
    29. 	}
    30.  
    31. 	ready = true;
    32. 	th.join();
    33.  
    34. 	return 0;
    35. }

    三. 互斥锁与原子操作

    3.1 多线程中的加锁与解锁

    加锁，是保证多线程场景下线程安全的一种手段，因为多个线程可能同时访问到临界资源，这就可能引发不可预料的结果。对访问临界资源的临界区代码加锁，就可以保证同一时刻只有一个线程的执行流进入临界区访问临界资源，从而保证线程安全。

    代码3.1是一种典型的线程不安全的场景，共有4个线程对全局变量count执行++操作，每个线程执行10000次++，当四个线程都退出时，我们希望count的值变为40000，然而实际运行的结果确远小于40000，并且每次运行的结果各不相同，这就是由于多线程执行流同时访问临界资源而引发的线程不安全问题。加锁可以避免上面的问题。

    代码3.1：多线程访问临界资源引发线程不安全问题

    1. #include <iostream>
    2. #include <thread>
    3. #include <vector>
    4. #include <Windows.h>
    5.  
    6. int count = 0;
    7. int g_thread_num = 4;
    8.  
    9. void add()
    10. {
    11. 	for (int i = 0; i < 10000; ++i)
    12. 	{
    13. 		++count;
    14. 	}
    15. }
    16.  
    17. int main()
    18. {
    19. 	std::vector<std::thread> vth(4);
    20. 	// 创建线程
    21. 	for (int i = 0; i < g_thread_num; ++i)
    22. 	{
    23. 		vth[i] = std::thread(add);
    24. 	}
    25.  
    26. 	// 等待线程
    27. 	for (int i = 0; i < g_thread_num; ++i)
    28. 	{
    29. 		vth[i].join();
    30. 	}
    31.  
    32. 	std::cout << "count = " << count << std::endl;
    33.  
    34. 	return 0;
    35. }

    3.1.1 mutex类

    接口函数功能
    mutex()默认构造函数
    mutex(const mutex& mtx) = delete禁止拷贝构造
    void lock()加锁
    void unlock()解锁

    对于代码3.1，如果我们对访问临界资源的代码++count进行加锁操作，那么就限制了某一时刻只能有一个执行流执行++count操作，这样就保证了线程安全，运行结果一定是count = 40000。

    代码3.2：对临界资源加锁

    1. #include <iostream>
    2. #include <thread>
    3. #include <vector>
    4. #include <mutex>
    5.  
    6. int count = 0;
    7. int g_thread_num = 4;
    8.  
    9. void add(std::mutex& mtx)
    10. {
    11. 	for (int i = 0; i < 10000; ++i)
    12. 	{
    13. 		mtx.lock();   // 加锁
    14. 		++count; 
    15. 		mtx.unlock(); // 解锁
    16. 	}
    17. }
    18.  
    19. int main()
    20. {
    21. 	std::mutex mtx;
    22.  
    23. 	std::vector<std::thread> vth(4);
    24. 	// 创建线程
    25. 	for (int i = 0; i < g_thread_num; ++i)
    26. 	{
    27. 		// 通过引用的方式，将互斥锁传递给线程函数
    28. 		vth[i] = std::thread(add, std::ref(mtx));
    29. 	}
    30.  
    31. 	// 等待线程
    32. 	for (int i = 0; i < g_thread_num; ++i)
    33. 	{
    34. 		vth[i].join();
    35. 	}
    36.  
    37. 	std::cout << "count = " << count << std::endl;
    38.  
    39. 	return 0;
    40. }

    3.1.2 lock_guard 类

    原型：template lock_guard { }

    如果采用lock()、unlock()的加锁和解锁方式，在lock和unlock之间抛异常，或者忘记调用unlock解锁，那么都有可能出现锁无法释放，造成死锁、执行流阻塞的问题。而采用lock_guard则可以很好的避免上面的问题，lock_guard在构造的时候会自动加锁，在离开作用域的时候由编译器自动调用其析构函数解锁。

    • lock_guard构造函数原型：explicit lock_guard(mutex_type& mtx)。
    • lock_guard不允许拷贝构造：lock_guard(const lock_guard& lock) = delete。

    代码3.3将代码3.2中的lock和unlock改为lock_guard的格式，来保证访问临界资源的安全性。

    代码3.3：通过lock_guard实现加锁和解锁

    1. int count = 0;
    2. int g_thread_num = 4;
    3.  
    4. void add(std::mutex& mtx)
    5. {
    6. 	for (int i = 0; i < 10000; ++i)
    7. 	{
    8. 		// 通过构造lock_guard类来加锁
    9. 		std::lock_guard<std::mutex> lock(mtx);
    10. 		++count; 
    11. 	} // 出作用域自动调用lock_guard的析构函数来解锁
    12. }
    13.  
    14. int main()
    15. {
    16. 	std::mutex mtx;
    17.  
    18. 	std::vector<std::thread> vth(4);
    19. 	// 创建线程
    20. 	for (int i = 0; i < g_thread_num; ++i)
    21. 	{
    22. 		// 通过引用的方式，将互斥锁传递给线程函数
    23. 		vth[i] = std::thread(add, std::ref(mtx));
    24. 	}
    25.  
    26. 	// 等待线程
    27. 	for (int i = 0; i < g_thread_num; ++i)
    28. 	{
    29. 		vth[i].join();
    30. 	}
    31.  
    32. 	std::cout << "count = " << count << std::endl;
    33.  
    34. 	return 0;
    35. }

    3.3 原子性操作

    原理性操作的概念：某个操作只有两种状态，要么完成，要么还没开始，不存在完成一部分的中间状态。如果我们对临界资源访问或修改的操作是原子的，那么就是线程安全的。

    C++内置atomic类，调用其接口函数，可以实现对指针或整型数据的原子性操作。

    • 对于整型数据intergal，atomic可以原子的实现以下操作：+=、-=、&=、|=、^= 。
    • 对于指针类型数据pointer，atomic可以原子的实现以下操作：+=、-= 。
    • atomic还支持原子的实现operator++、operator--操作。

    代码3.4在3.3的基础上继续进行修改，定义std::atomic count = 0，这样线程函数中的++count就变为了原子性操作，也就保证了线程的安全性。如果线程函数中执行 count += val、count -= val等操作，也是线程安全的。

    代码3.4：通过atomic实现原子性操作

    1. #include <iostream>
    2. #include <thread>
    3. #include <vector>
    4. #include <atomic>
    5.  
    6. // 通过atmoic，让针对count的操作变为原子的
    7. std::atomic<int> count = 0;
    8. int g_thread_num = 4;
    9.  
    10. void add()
    11. {
    12. 	for (int i = 0; i < 10000; ++i)
    13. 	{
    14. 		count++;
    15. 	} 
    16. }
    17.  
    18. int main()
    19. {
    20.  
    21. 	std::vector<std::thread> vth(4);
    22. 	// 创建线程
    23. 	for (int i = 0; i < g_thread_num; ++i)
    24. 	{
    25. 		// 通过引用的方式，将互斥锁传递给线程函数
    26. 		vth[i] = std::thread(add);
    27. 	}
    28.  
    29. 	// 等待线程
    30. 	for (int i = 0; i < g_thread_num; ++i)
    31. 	{
    32. 		vth[i].join();
    33. 	}
    34.  
    35. 	std::cout << "count = " << count << std::endl;
    36.  
    37. 	return 0;
    38. }

    四. 条件变量

    4.1 线程互斥的缺陷

    如代码4.1所示，在多线程场景下，在线程函数中，仅仅是通过lock、unlock对临界区进行加锁和解锁，还要在临界区检查临界资源是否就绪，此时不加以其他限制，就可能存在这样的问题：(1). 单个函数频繁申请到锁，造成其他线程的饥饿问题。(2). 如果临界资源长时间不就绪，那么频繁的进行 加锁 -> 检测临界资源是否就绪 -> 解锁 操作，会造成线程资源的浪费。

    为了解决代码4.1的问题，线程同步被引入，线程同步是指让多个线程按照特定的次序被调度以及访问临界资源，如果检测到临界资源不就绪，线程就挂起等待。通过控制条件变量的等待和唤醒，可以实现线程的同步。

    代码4.1：存在缺陷的线程互斥代码

    1. #include <iostream>
    2. #include <thread>
    3. #include <mutex>
    4. #include <vector>
    5. #include <Windows.h>
    6.  
    7. int count = 0;
    8. bool ready = false;
    9. const int g_thread_num = 4;
    10.  
    11. void threadRoutine(std::mutex& mtx)
    12. {
    13. 	while (true)
    14. 	{
    15. 		// 通过lock_guard控制加锁解锁
    16. 		std::lock_guard<std::mutex> lock(mtx);  
    17.  
    18. 		if (ready)  // 检查临界资源的就绪情况
    19. 		{
    20. 			++count;
    21. 			std::cout << "[" << std::this_thread::get_id() << "]" << "count: " << count << std::endl;
    22. 		}
    23.  
    24. 		std::this_thread::sleep_for(std::chrono::milliseconds(500));
    25. 	}
    26. }
    27.  
    28. int main()
    29. {
    30.  
    31. 	std::mutex mtx;
    32. 	std::vector<std::thread> vth(g_thread_num);
    33.  
    34. 	// 创建线程
    35. 	for (int i = 0; i < g_thread_num; ++i)
    36. 	{
    37. 		vth[i] = std::thread(threadRoutine, std::ref(mtx));
    38. 	}
    39.  
    40. 	Sleep(3000);
    41. 	ready = true;   // 主线程休眠3s才让临界资源就绪
    42.  
    43. 	// 等待线程
    44. 	for (int i = 0; i < g_thread_num; ++i)
    45. 	{
    46. 		vth[i].join();
    47. 	}
    48.  
    49. 	return 0;
    50. }

    4.2 condition_variable 实现线程同步

    通过定义condition_variable对象，调用等待条件变量、唤醒条件变量等方法，可以控制线程按照指定顺序运行，同时避免频繁检查临界资源是否就绪造成线程资源的浪费。

    表4.1 condition_variable的主要接口函数
    函数原型功能
    conditional_variable( )默认构造函数
    conditional_variable(const conditional_variable&) = delete禁止拷贝构造
    void wait(unique_lock& lck, predicate pred) 等待条件变量
    void notify_one() 唤醒一个等待条件变量的线程
    void notify_all()唤醒等待条件变量的全部线程

    其中，wait的底层实现为：while(!prev) { 等待条件变量... } 

    代码4.2创建了3个线程，通过检测主线程中定义的int ready的值，控制线程的等待条件变量和唤醒，来让线程运行的顺序为3、2、1，实现线程的同步。

    代码4.2：通过条件变量控制线程运行的顺序

    1. #include <iostream>
    2. #include <thread>
    3. #include <mutex>
    4. #include <vector>
    5. #include <Windows.h>
    6.  
    7. int main()
    8. {
    9. 	volatile int ready = 3;
    10. 	std::mutex mtx;
    11. 	std::condition_variable cv;
    12.  
    13. 	// 线程1
    14. 	std::thread th1([&]() {
    15. 		while (true)
    16. 		{
    17. 			std::unique_lock<std::mutex> lock(mtx);
    18. 			// 检查临界资源是否就绪
    19. 			cv.wait(lock, [&ready]() { return ready == 1; });
    20. 			std::cout << "thread 1" << std::endl;
    21. 			ready = 3;
    22. 			std::this_thread::sleep_for(std::chrono::milliseconds(300));
    23. 			cv.notify_all();   // 唤醒一个线程
    24. 		}
    25. 	});
    26.  
    27. 	std::thread th2([&]() {
    28. 		while (true)
    29. 		{
    30. 			std::unique_lock<std::mutex> lock(mtx);
    31. 			// 检查临界资源是否就绪
    32. 			cv.wait(lock, [&ready]() { return ready == 2; });
    33. 			std::cout << "thread 2" << std::endl;
    34. 			ready = 1;
    35. 			std::this_thread::sleep_for(std::chrono::milliseconds(300));
    36. 			cv.notify_all();   // 唤醒一个线程
    37. 		}
    38. 	});
    39.  
    40. 	std::thread th3([&]() {
    41. 		while (true)
    42. 		{
    43. 			std::unique_lock<std::mutex> lock(mtx);
    44. 			// 检查临界资源是否就绪
    45. 			cv.wait(lock, [&ready]() { return ready == 3; });
    46. 			std::cout << "thread 3" << std::endl;
    47. 			ready = 2;
    48. 			std::this_thread::sleep_for(std::chrono::milliseconds(300));
    49. 			cv.notify_all();   // 唤醒一个线程
    50. 		}
    51. 	});
    52.  
    53. 	th1.join();
    54. 	th2.join();
    55. 	th3.join();
    56.  
    57. 	return 0;
    58. }

    五. 单例模式的线程安全问题

    5.1 饿汉模式的线程安全问题

    饿汉模式，是指在程序开始运行（进入到main函数）之前，就创建好单例对象，饿汉模式的优点和缺点如下：

    • 优点：(1). 实现和调用较为方便  (2). 更容易保证线程安全 -- 主要针对单例类实例化时的线程安全问题，如果涉及到临界资源的访问，还是要通过加锁的方式保证线程安全
    • 缺点：(1). 单例类实例化，延缓软件启动速度  (2). 存在多个单例类时无法确定实例化顺序。

    我们可以认为，如果我们仅考虑单例类对象本身的实例化，饿汉模式是线程安全的。

    代码5.1：饿汉模式实现单例类

    1. class singleton 
    2. {
    3. public:
    4. 	static singleton _inst;   // 唯一一个实例化对象
    5.  
    6. 	// 禁止拷贝和赋值
    7. 	singleton(const singleton& st) = delete;
    8. 	singleton& operator=(const singleton& st) = delete;
    9.  
    10. private:
    11. 	// 构造函数
    12. 	singleton(int s = 10) : _s(s)
    13. 	{ }
    14.  
    15. 	int _s;
    16. };
    17.  
    18. singleton singleton::_inst;  // 实例化唯一一个类对象

    5.2 懒汉模式的线程安全问题

    懒汉模式，就是第一次使用单例对象时才实例化，懒汉模式的优缺点如下：

    • 优点：(1). 不延缓软件的启动速度  (2). 如果有多个单例对象可以控制实例化的顺序
    • 缺点：(1). 设计复杂  (2). 保证线程安全相对困难

    一般来说，懒汉模式的实现方法是在singleton中定义指向singleton堆区对象的指针_ptr，初值设为nullptr并提供GetInstance函数获取指向单例对象的指针，第一次调用GetInstance会检测到_ptr为空指针，此时会new出一个singleton对象，那么我们可能会写出代码5.2，这并不是线程安全的！

    如果有两个线程同时进入 if(ptr == nullptr) 内部，那么new singleton就会被调用两次，引发线程不安全问题。

    代码5.2：线程不安全的懒汉单例模式

    1. #include 
    2.  
    3. class singleton
    4. {
    5. public:
    6. 	static singleton* GetInstance(int s = 10)
    7. 	{
    8. 		// 线程不安全
    9. 		// 如果多个线程同时进入if内部，则会实例化出多份singleton对象
    10. 		if (_pinst == nullptr)
    11. 		{
    12. 			_pinst = new singleton(s);
    13. 		}
    14. 		return _pinst;
    15. 	}
    16.  
    17. 	int get_s() { return _s; }
    18.  
    19. private:
    20. 	singleton(int s)  // 构造函数私有化
    21. 		: _s(s)
    22. 	{ }
    23.  
    24. 	int _s;
    25.  
    26. 	// 指向单例对象的指针，初值设为nullptr
    27. 	// 第一次调用后改变为指向堆区singleton单例对象的指针
    28. 	static singleton* _pinst;
    29. };

    为了确保线程安全，我们必须对临界区代码（访问singleton *_pinst的代码）进行加锁，这样，我们就会写出如代码5.3所示的懒汉模式单例类，这个单例类在构造的时候是线程安全的。但是，这样的代码依旧存在缺陷，单例对象在创建成功后_pinst的值永远为nullptr，此时判断_pinst==nullptr是否成立是线程安全的，在if(_pinst == nullptr) { ... } 前后加锁解锁，会造成不必要的资源浪费。

    代码5.3：能保证线程安全，但存在缺陷的懒汉单例模式

    1. #include <iostream>
    2. #include <mutex>
    3.  
    4. class singleton
    5. {
    6. public:
    7. 	static singleton* GetInstance(int s = 10)
    8. 	{
    9. 		// 如果单例类已经创建，频繁加锁解锁会造成资源浪费
    10. 		_mtx.lock();  // 加锁
    11. 		if (_pinst == nullptr)
    12. 		{
    13. 			_pinst = new singleton(s);
    14. 		}
    15. 		_mtx.unlock();
    16.  
    17. 		return _pinst;
    18. 	}
    19.  
    20. 	int get_s() { return _s; }
    21.  
    22. private:
    23. 	singleton(int s)  // 构造函数私有化
    24. 		: _s(s)
    25. 	{ }
    26.  
    27. 	int _s;
    28.  
    29. 	// 指向单例对象的指针，初值设为nullptr
    30. 	// 第一次调用后改变为指向堆区singleton单例对象的指针
    31. 	static singleton* _pinst;
    32. 	static std::mutex _mtx;    // 互斥锁
    33. };
    34.  
    35. singleton* singleton::_pinst = nullptr;   // 静态成员初值设为空
    36. std::mutex singleton::_mtx;    // 互斥锁初始化

    代码5.4在5.3的基础上进一步修改，在GetInstance函数的执行流进入到了if(_pinst == nulptr) { ... }内部时，才进行加锁解锁，并在if内部加锁与解锁之间再次判断_pinst==nullptr是否成立，如果依旧成立，说明确实没有singleton对象被实例化出来，此时再new单例对象，并返回指向堆区单例对象的指针。

    这样版的GetInstance函数内部执行双层if判断_pinst == nullptr是否成立，外层判断是为了保证有一个单例对象被创建出来，内层判断前后要进行加锁和解锁操作，为了确保在由多个执行流进入外层if的情况下不出现线程安全问题。

    代码5.4：双重 if(_pinst == nullptr) 判断实现线程安全的懒汉单例模式

    1. #include <iostream>
    2. #include <mutex>
    3.  
    4. class singleton
    5. {
    6. public:
    7. 	static singleton* GetInstance(int s = 10)
    8. 	{
    9. 		// 外层if确保有一个单例对象被实例化出来
    10. 		if (_pinst == nullptr)
    11. 		{
    12. 			// 内层if判断确保多执行流进入外层if时
    13. 			// 不会出现实例化出多个singleton对象的问题，以确保线程安全
    14. 			_mtx.lock();
    15. 			if (_pinst == nullptr)
    16. 			{
    17. 				_pinst = new singleton(s);
    18. 			}
    19. 			_mtx.unlock();
    20. 		}
    21.  
    22. 		// 双层if判断，可以防止在GetInstance频繁被调用的场景下
    23. 		// 每次都进行加锁和解锁，造成线程资源的浪费
    24. 	
    25. 		return _pinst;
    26. 	}
    27.  
    28. 	int get_s() { return _s; }
    29.  
    30. private:
    31. 	singleton(int s)  // 构造函数私有化
    32. 		: _s(s)
    33. 	{ }
    34.  
    35. 	int _s;
    36.  
    37. 	// 指向单例对象的指针，初值设为nullptr
    38. 	// 第一次调用后改变为指向堆区singleton单例对象的指针
    39. 	static singleton* _pinst;
    40. 	static std::mutex _mtx;    // 互斥锁
    41. };
    42.  
    43. singleton* singleton::_pinst = nullptr;   // 静态成员初值设为空
    44. std::mutex singleton::_mtx;    // 互斥锁初始化

    六. 智能指针的线程安全问题

    以最常用的智能指针shared_ptr为例，shared_ptr允许多个RAII对象指向同一份资源，通过底层的引用计数器，来保证在没有shared_ptr对象指向内部资源时相关的资源可以被析构。

    智能指针shared_ptr底层的引用计数器为共享资源，对于拷贝构造、赋值等需要访问引用计数器的相关操作，如不加锁，会引发线程不安全问题。代码6.1为线程安全版本的shared_ptr模拟实现，在使用引用计数器的时候，都会进行加锁和解锁处理。

    注意：C++标准库中提供的shared_ptr保证拷贝构造和赋值是线程安全的，但是对于其所指向资源的访问和修改，需要用户自行加锁来保证线程安全。

    代码6.2：线程安全的shared_ptr模拟实现

    1. #include <iostream>
    2. #include <mutex>
    3. #include <vector>
    4.  
    5. namespace zhang
    6. {
    7. 	template<class T>
    8. 	class shared_ptr
    9. 	{
    10. 	public:
    11. 		// 构造函数
    12. 		shared_ptr(T* ptr = nullptr)
    13. 			: _ptr(ptr)
    14. 			, _pcount(new int(1))
    15. 			, _pmtx(new std::mutex)
    16. 		{ }
    17.  
    18. 		// 拷贝构造函数
    19. 		shared_ptr(const shared_ptr& sp)
    20. 			: _ptr(sp._ptr)
    21. 			, _pcount(sp._pcount)
    22. 			, _pmtx(sp._pmtx)
    23. 		{
    24. 			AddCount();  // 引用计数+1函数
    25. 		}
    26.  
    27. 		// 赋值函数
    28. 		shared_ptr& operator=(const shared_ptr& sp)
    29. 		{
    30. 			// 排除自赋值
    31. 			if (sp._ptr != _ptr)
    32. 			{
    33. 				Release();   // 资源释放函数
    34. 				_pcount = sp._pcount;
    35. 				_ptr = sp._ptr;
    36. 				_pmtx = sp._pmtx;
    37. 				AddCount();
    38. 			}
    39. 			return *this;
    40. 		}
    41.  
    42. 		// 析构函数
    43. 		~shared_ptr()
    44. 		{
    45. 			Release();
    46. 		}
    47.  
    48. 		T& operator*()
    49. 		{
    50. 			return *_ptr;
    51. 		}
    52.  
    53. 		T* operator->()
    54. 		{
    55. 			return &(*_ptr);
    56. 		}
    57.  
    58. 	private:
    59. 		void AddCount()
    60. 		{
    61. 			_pmtx->lock();   // 加锁
    62. 			++(*_pcount);
    63. 			_pmtx->unlock();
    64. 		}
    65.  
    66. 		void Release()
    67. 		{
    68. 			bool flag = false;  // 标识是否还有智能指针指向资源
    69.  
    70. 			_pmtx->lock();
    71. 			if (--(*_pcount) == 0)
    72. 			{
    73. 				delete _ptr;
    74. 				delete _pcount;
    75. 				flag = true;
    76. 			}
    77. 			_pmtx->unlock();
    78.  
    79. 			if (flag) delete _pmtx;
    80. 		}
    81.  
    82. 		T* _ptr;
    83. 		int* _pcount;
    84. 		std::mutex* _pmtx;
    85. 	};
    86. }
    87.  
    88. int main()
    89. {
    90. 	zhang::shared_ptr<int> sp1(new int(2));
    91. 	zhang::shared_ptr<int> sp2(new int(4));
    92. 	std::cout << *sp1 << std::endl;
    93. 	std::cout << *sp2 << std::endl;
    94. 	sp2 = sp1;
    95. 	std::cout << *sp2 << std::endl;
    96.  
    97. 	std::vector<std::thread> vth(10000);
    98. 	for (int i = 0; i < 10000; ++i)
    99. 	{
    100. 		vth[i] = std::thread([&]() { 
    101. 			zhang::shared_ptr<int> sp(sp1); 
    102. 			// std::cout << *sp << std::endl;
    103. 		});
    104. 	}
    105.  
    106. 	for (int i = 0; i < 10000; ++i)
    107. 	{
    108. 		vth[i].join();
    109. 	}
    110.  
    111. 	return 0;
    112. }

    七. 总结

    • C++ 11标准库提供thread类，通过创建thread类对象，可以创建多线程，thread不能支持拷贝构造和拷贝赋值，但可以支持移动构造和移动赋值。
    • std::this_thread中提供了让出时间片、获取线程id以及线程休眠的相关接口。
    • 多线程访问临界资源的场景下，需要加锁以保证临界资源的安全性，C++标准库提供mutex类，可以实现加锁和解锁。同时为了避免加锁和解锁之间因为异常安全性问题导致执行流没有运行到解锁的位置，C++标准库又提供了lock_guard类，lock_guard在构造阶段会加锁，在析构时会自动解锁。
    • 通过控制多线程对同一个条件变量的等待和唤醒，可以实现线程间的同步执行。
    • 用饿汉模式实现单例，一般可以保证线程安全。懒汉模式在获取单例对象的GetInstance函数中，需要使用双层if来判断，在保证线程安全的同时避免不必要的资源浪费。
    • shared_ptr底层的引用计数器属于共享资源，在拷贝构造和赋值函数中，需要加锁以保证线程安全，C++标准库中提供的shared_ptr可以保证拷贝构造和赋值函数的线程安全，但是在访问指向的资源时，需要用户自行加锁解锁以保证线程安全。
  • 相关阅读:
    linux高性能服务器
    常量接口 vs 常量类 vs 枚举区别
    DockerFile打包项目实战解析，一文读懂dockerfile打包
    CKA 真题练习（十六）备份还原etcd
    2024华数杯数学建模竞赛选题建议+初步分析
    第九届世界渲染大赛什么时候开始举办？
    sql注入information_schema代替，无列名注入之[SWPU2019]Web11
    [机器学习] 通俗理解机器学习分类模型评估指标-准确率、精准率、召回率
    最近学习内容(2023-10-22)
    R3LIVE源码解析(10) — R3LIVE中r3live_vio.cpp文件
  • 原文地址：https://blog.csdn.net/weixin_43908419/article/details/132736941