C++线程安全

线程安全

什么是线程安全

解释一：
   线程安满是指代码在多线程访问某个类（方法大概对象）时，这个类始终能体现出精确的举动。换种说法，如果一个类大概对象能够在多线程环境下运行，其中内容不会因为多线程的并发访问而输出错误结果或状态，那么它就是线程安全的
  解释二：
   在多线程同时对临界区资源(共享资源), 最终这个临界区资源的最终操作结果的值是精确的，那么就是线程安全，反之就是线程不安全
  线程安全的核心问题

• 原子性
  

   这点上，跟数据库事务的原子性概念差不多，即一个操作（可能含有多个子操作）要么全部执行完毕（即生效），要么全部都不执行（都不生效）
关于这个内容有个很简单的转账问题：C有事需要30万，他的余额剩下10万。于是，他想向A借钱，但是A只能借10万，所幸B还能借他10万，他让A和B向他的银行账户转账。A在向C举行转账之前，读取C的余额为10万，加上他向C转账的10万，计算得出此时C的账户应该有20万，但还未来得及将结果写入，此时B的转账请求来了；B同样发现C的余额为10万，然后转入10万后并写入，此时A同样将计算的30万写入到C的余额。这种环境下，C的最终余额为20万，并非预期的30万
  

• 可见性
  

   指当一个线程修改了对象的状态大概值的时间，其他线程能够同步举行看到，这称为可见性。
如果此时两个线程处于差别的CPU，那么在线程1改变了 i 的值还未刷新到主存，线程2也要改变 i 的值，此时这个变量 i 的值肯定还是之前的值，线程1对变量的修改，线程2并没有看到，这就是可见性问题
  

• 有序性
  

   程序执行的次序需要按照代码的先后次序执行，在多线程编程时需要思量这个问题。
  示例：抢票
当多个线程同时共享同一个全局变量或静态变量（局部变量不会），并做写操作时，可能会发生数据冲突问题，也就是线程安全问题。但读操作并不会发生数据冲突问题

1. // 操作共享变量会有问题的抢票代码
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <string.h>
5. #include <unistd.h>
6. #include <pthread.h>
8. int ticket = 100;
10. void *route(void *arg)
11. {
12.     char *id = (char*)arg;
13.     while ( 1 ) {
14.         if ( ticket > 0 ) {
15.             usleep(1000);
16.             printf("%s sells ticket:%d\n", id, ticket);
17.             ticket--;
18.         } else {
19.             break;
20.         }
21.     }
22. }
24. int main( void )
25. {
26.     pthread_t t1, t2, t3, t4;
28.     pthread_create(&t1, NULL, route, (void*)"thread 1");
29.     pthread_create(&t2, NULL, route, (void*)"thread 2");
30.     pthread_create(&t3, NULL, route, (void*)"thread 3");
31.     pthread_create(&t4, NULL, route, (void*)"thread 4");
33.     pthread_join(t1, NULL);
34.     pthread_join(t2, NULL);  
35.     pthread_join(t3, NULL);
36.     pthread_join(t4, NULL);
38.     return 0;
39. }

复制代码

结果：

从这里的输出结果来看，售票数量出现了负数，体现此时票数已经出现了问题，因为不可能两个人同时在一个位置吧？这就是线程不安全导致出现的问题了。
如何保证线程安全？

在C++中，可以利用一下几种方式来确保 线程安全
   1.利用互斥量（mutex）来对临界资源(共享资源)举行保护。互斥量可以防止多个线程同时访问临界资源，从而制止数据竞争所导致的问题。
2.利用读写锁（reader-writer lock）来对共享资源举行保护。读写锁允许多个读线程同时访问共享资源，但是写线程必须独占资源。这样可以在保证线程安全的同时，尽可能的提高系统的并发性
3.利用条件变量（condition variable）来协调线程之间的协作。条件变量可以用来在线程之间传递信号，从而控制线程的执行流程。
4.利用信号量（POSIX），用于却表多个进程/线程大概差别部分的同一进程在访问共享资源的安全性。他们可以通过在差别的进程或线程之间共享来构建并发程序，从而制止竞争条件和死锁等并发编程问题。
  1.利用互斥量（mutex）来保护共享资源：

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include <iostream>
3. #include <stdlib.h>
4. #include <string>
5. #include <unistd.h>
6. #include <thread>
7. #include <mutex>
9. int tickets = 100;
10. std::mutex mutex;
12. void route()
13. {
14.         //这里也采用了RAII思想
15.     std::lock_guard<std::mutex> lock(mutex);
16.     while ( 1 ) {
17.         //共享资源
18.         if ( tickets > 0 ) {
19.             std::cout << "get a ticket: " << tickets-- << std::endl;
20.             usleep(1000);
21.         } else {
22.             break;
23.         }
24.         // 抢完票的后序动作
25.         usleep(1000);
26.     }
27. }
29. int main()
30. {
31.     std::thread t1(route);
32.     std::thread t2(route);
33.     std::thread t3(route);
34.     std::thread t4(route);
36.     t1.join();
37.     t2.join();
38.     t3.join();
39.     t4.join();
41.     return 0;
42. }

复制代码

  1.上述例子中，我们定义了一个全局互斥量 mutex 和一个共享资源 ticket。然后在route函数中，我们利用 std::lock_guard对mutex举行加锁。这样就可以保证在同一时间，只能有一个线程可以访问 ticket。
2.在 main 函数中。我们创建了四个线程 t1，t2，t3 和 t4，并让它们都执行route抢票函数操作。由于 在一个线程访问到共享资源之后，会用 mutex 对共享资源举行加锁，以是此时只有一个线程能够举行抢票(修改ticket的值)，因此最终结果就是 ticket == 0。

  2.利用读写锁（reader-writer lock）来保护共享资源：

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include <iostream>
3. #include <stdlib.h>
4. #include <string>
5. #include <thread>
6. #include <shared_mutex>
7. #include <Windows.h>
9. int tickets = 100;
10. std::shared_mutex mutex; //全局读写锁
12. void route()
13. {
14.     std::unique_lock<std::shared_mutex> lock(mutex); //上写锁
15.     while (1) {
16.         //共享资源
17.         if (tickets > 0) {
18.             std::cout << "get a ticket: " << tickets-- << std::endl;
19.             Sleep(10);
20.         }
21.         else {
22.             break;
23.         }
24.         // 抢完票的后序动作
25.         Sleep(10);
26.     }
27. }
29. void readRoute()
30. {
31.     std::shared_lock<std::shared_mutex> lock(mutex); //上读锁
32.     std::cout << "tickets is : " << tickets << std::endl;
33. }
35. int main()
36. {
37.     std::thread t1(route);
38.     std::thread t2(route);
39.     std::thread t3(readRoute);
40.     std::thread t4(readRoute);
42.     t1.join();
43.     t2.join();
44.     t3.join();
45.     t4.join();
47.     return 0;
48. }

复制代码

  1.在这个例子中，我们定义类一个读写锁和一个共享资源 tickets。 然后在 route函数中，我们利用std::unique_lock 对 mutex 举行加写锁。这时可以保证在同一时间，只能有一个写线程对 tickets 的值举行修改。
2.在readroute函数中，我们利用 std::shared_lock 对 g_mutex 举行加读锁。这样可以保证在同意是可以，能够有多个读线程可以同时读取 g_counter 的值，但是写线程必须等待全部的读线程结束后才能执行；同理，如果写线程对共享资源举行操作，此时读线程也无法获取到共享资源
  常见的读写锁操作

• 读锁定（Read Lock）：请求对共享资源的读取权限。如果没有线程持有写锁，则允许多个读线程同时得到读锁。
  
• 读解锁（Read Unlock）：释放读锁，当全部读锁都被释放后，写线程可以请求获取写锁。
  
• 写锁定（Write Lock）：请求对共享资源的写权限。写锁请求会阻塞，直到没有任何读锁或写锁被其他线程持有。
  
• 写解锁（Write Unlock）：释放写锁，使得其他读线程或写线程可以对资源举行访问。
  

3.利用条件变量（condition variable）使线程能够更好的协调工作：

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include <iostream>
3. #include <stdlib.h>
4. #include <string>
5. #include <thread>
6. #include <mutex>
7. #include <Windows.h>
8. #include <condition_variable>
10. int tickets = 100;
11. bool flag = false;
12. std::mutex mutex; //全局锁
13. std::condition_variable cv;
15. void route1()
16. {
17.     std::unique_lock<std::mutex> lock(mutex);
18.     while (1) {
19.         //共享资源
20.         if (tickets > 0) {
21.             std::cout << "get a ticket: " << tickets-- << std::endl;
22.             Sleep(10);
23.         }
24.         else {
25.             flag = true;//将标志符置为true，并通知线程2
26.             cv.notify_one();
27.             break;
28.         }
29.         // 抢完票的后序动作
30.         Sleep(10);
31.     }
32. }
34. void route2()
35. {
36.     std::unique_lock<std::mutex> lock(mutex);
37.     while (!flag)
38.     {
39.         cv.wait(lock);
40.     }
41.     std::cout << "thread 2 finished" << std::endl;
42. }
44. int main()
45. {
46.     std::thread t1(route1);
47.     std::thread t2(route2);
49.     t1.join();
50.     t2.join();
52.     return 0;
53. }

复制代码

   

• 这个例子中，我们定义了一个互斥量 mutex 和一个条件变量 cv。我们还定义了一个全局变量 flag，用于标志抢票是否完成。
  2.在线程1，在执行完抢票之后，我们将 flag 置为 true，并利用 cv_notify_one()函数来通知线程2
  3.在线程 2 中，我们利用 while (!g_flag) 循环检测 g_flag 的值。如果 flag 为 false，则利用 cv.wait(lock) 函数等待通知，否则执行后续的操作。
  4.当线程 1 通知线程 2 时，线程 2 将被唤醒，并继承往下执行。最终，线程 2 会输出 “thread 2 finished”。
  5.通过这个例子，我们可以看到，利用条件变量可以在线程间协调协作，使得线程可以根据某些条件的改变而被唤醒或等待。
  

  4.利用信号量来保证线程安全

1. #include <semaphore>
2. #include <thread>
3. #include <iostream>
5. std::semaphore sem(5); // 创建信号量，初始值为 5
7. void thread_func() {
8.     sem.wait(); // 等待信号量的值大于 0
9.     std::cout << "Thread " << std::this_thread::get_id() << " is accessing the resource." << std::endl;
10.     // 访问共享资源
11.     sem.post(); // 释放信号量的值
12. }
14. int main() {
15.     std::thread threads[10]; // 创建 10 个线程
16.     for (int i = 0; i < 10; ++i) {
17.         threads[i] = std::thread(thread_func);
18.     }
19.     for (int i = 0; i < 10; ++i) {
20.         threads[i].join();
21.     }
22.     return 0;
23. }

复制代码

  在这个示例中，我们创建了一个信号量，初始值为 5，体现共享资源可以被 5 个线程同时访问。每个线程在访问共享资源之前会等待信号量的值大于 0，如果值为 0，则会阻塞直到其他线程释放信号量的值。

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