【C++】验证STL容器线程不安全

概要

在并发编程中，线程安满是确保多个线程在同时访问共享资源时，不会引起数据竞争或意外的举动。在C++中，std::vector通常并不是线程安全的，因此在多线程环境中对std::vector举行读写操作大概会导致未界说举动。本文将通过实例验证std::vector的线程不安全性，并讨论如何解决这一题目。
整体架构流程

本文将分以下几部分讲解如何验证std::vector的线程不安全性：
1、多线程操作std::vector示例代码：构建一个简朴的C++代码示例，在多线程中对std::vector执行插入和读取操作。
2、题目分析：分析代码在运行时出现的线程题目，分析出现的原因
3、解决方法：介绍一下解决的方法。
技术名词表明

线程安全（Thread Safety）：指在多线程步伐中，多个线程访问共享资源时，不会产生数据竞争或未界说举动。
数据竞争（Data Race）：多个线程并发访问共享资源，并且至少一个线程执行写操作时，发生的竞争征象。
锁（Mutex）：一种同步机制，用于防止多个线程同时访问共享资源。
技术细节

示例代码

以下代码展示了一个多线程环境中对std::vector举行读写操作的示例，验证其线程不安全性。

1. #include <iostream>
2. #include <pthread.h>
3. #include <string>
4. #include <vector>
5. #include <unistd.h>
6. using namespace std;
8. class Thread
9. {
10. public:
11.     Thread(string &name) : _threadname(name) {}
12.     bool start()
13.     {
14.         sleep(1);//这里sleep是为了让现象变得固定，不加sleep，则现象就太随机，不容易画图分析
15.         int n = pthread_create(&_tid, nullptr, threadroutine, this);
16.         if (n == 0)
17.         {
18.             return true;
19.         }
20.         return false;
21.     }
23.     static void *threadroutine(void *args)
24.     {
25.       
26.         Thread *self = static_cast<Thread *>(args);
27.         cout << self->_threadname << endl;
28.         return nullptr;
29.     }
30.     void Join()
31.     {
32.         pthread_join(_tid, nullptr);
33.     }
35. private:
36.     pthread_t _tid;
37.     std::string _threadname;
38. };
40. int main()
41. {
42.     vector<Thread> threads;
43.     for (int i = 0; i < 10; i++)
44.     {
45.         string name = "thread-" + to_string(i);
46.         Thread thread(name);
47.         threads.push_back(thread);
48.         threads[i].start();
49.       
50.     }
51.     for (auto &thread : threads)
52.     {
53.         thread.Join();
54.     }
55.     return 0;
56. }

复制代码

代码征象

可以发现，有些_threadname没有打印出来，有些打印出来了，因为加了sleep的原因，这个征象还是比较固定，容易分析的，那么原因出在哪了，没错，就是vector，vector的扩容题目。
分析代码

   线程并发执行引发的vector扩容造成的线程安全题目
  

   分析征象
  

来验证一下vector的扩容

   只必要添加一行，std::cout<<threads.capacity()<<std::endl;

1. for (int i = 0; i < 10; i++)
2.     {
3.         std::cout<<threads.capacity()<<std::endl;
4.         string name = "thread-" + to_string(i);
5.         Thread thread(name);
6.         threads.push_back(thread);
7.         threads[i].start();
8.       
9.     }

复制代码

  征象
  

至此，验证STL容器的vector线程不安全完成。
解决方法

   这里提2种解决办法
1、先把Thread放进vector，最后再遍历vector来启动
2、举行加锁，这里的加锁也要留心，加锁不正确，仍然会导致线程安全题目

1. int main()
2. {
3.     vector<Thread> threads;
4.     for (int i = 0; i < 10; i++)
5.     {
6.         string name = "thread-" + to_string(i);
7.         Thread thread(name);
8.         threads.push_back(thread);
9.     }
10.     for (int i = 0; i < 10; i++)
11.     {
12.         threads[i].start();
13.     }
14.     for (auto &thread : threads)
15.     {
16.         thread.Join();
17.     }
18.     return 0;
19. }

复制代码

  加锁的代码，注意加锁和释放锁的机遇，不正确的加锁仍然会有题目

1. #include <iostream>
2. #include <pthread.h>
3. #include <string>
4. #include <vector>
5. #include <unistd.h>
6. using namespace std;
7. pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
8. class Thread
9. {
10. public:
11.     Thread(string &name) : _threadname(name) {}
12.     bool start()
13.     {
14.         pthread_mutex_lock(&lock);
15.         // sleep(1); // 这里sleep是为了让现象变得固定，不加sleep，则现象就太随机，不容易画图分析
16.         int n = pthread_create(&_tid, nullptr, threadroutine, this);
17.         if (n == 0)
18.         {
19.             return true;
20.         }
21.         return false;
22.     }
24.     static void *threadroutine(void *args)
25.     {
26.         
27.         Thread *self = static_cast<Thread *>(args);
28.         cout << self->_threadname << endl;
29.         pthread_mutex_unlock(&lock);
30.         return nullptr;
31.     }
32.     void Join()
33.     {
34.         pthread_join(_tid, nullptr);
35.     }
37. private:
38.     pthread_t _tid;
39.     std::string _threadname;
40. };
42. int main()
43. {
44.     vector<Thread> threads;
45.     for (int i = 0; i < 10; i++)
46.     {
47.         
48.         string name = "thread-" + to_string(i);
49.         Thread thread(name);
50.         pthread_mutex_lock(&lock);
51.         threads.push_back(thread);
52.         pthread_mutex_unlock(&lock);
53.         threads[i].start();
54.     }
55.     for (auto &thread : threads)
56.     {
57.         thread.Join();
58.     }
59.     return 0;
60. }

复制代码

小结

在多线程场景中，std::vector 并发访问和扩容会导致数据竞争、无效指针、内存泄漏等题目。通过该案例分析，能够能加深刻的熟悉到线程安全带来的危害，实验的是string，那如果是金钱呢，线程安全题目不可忽视

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。