多线程比单线程的程序耗时还要多:锁用得太频繁

东方耀

多线程比单线程的程序耗时还要多:锁用得太频繁

1. #include <iostream>
   
2. #include <list>
   
3. #include <string>
   
4. #include <chrono>
   
5. #include <thread>
   
6. 
   
7. class Message
   
8. {
   
9. private:
   
10.     std::string m_data;
    
11. public:
    
12.     Message(std::string d);
    
13.     const std::string& data();
    
14. };
    
15. 
    
16. Message::Message(std::string d) : m_data(d)
    
17. {
    
18. }
    
19. 
    
20. const std::string& Message::data(){
    
21.     return m_data;
    
22. }
    
23. 
    
24. std::list<Message> global_message_list;
    
25. 
    
26. 
    
27. void worker(){
    
28.     while(!global_message_list.empty()){
    
29.         auto iter = global_message_list.begin();
    
30.         //do real work and erase it!
    
31.         global_message_list.erase(iter);
    
32.     }
    
33. }
    
34. 
    
35. 
    
36. 
    
37. // 单线程编程
    
38. 
    
39. //real        0m11.185s
    
40. // user        0m0.186s
    
41. // sys        0m0.117s
    
42. int main(){
    
43. 
    
44.     for(int i=0;i<10000;++i){
    
45.         global_message_list.push_back("this is a test"+std::to_string(i));
    
46.     }
    
47. 
    
48.     worker();
    
49. 
    
50.     for(int i=0;i<10000;++i){
    
51.         std::this_thread::sleep_for(std::chrono::milliseconds(1));
    
52.         global_message_list.push_back("the second "+std::to_string(i));
    
53.     }
    
54.     worker();
    
55. 
    
56.     return 0;
    
57. }

复制代码

1. #include <iostream>
   
2. #include <list>
   
3. #include <vector>
   
4. #include <thread>
   
5. #include <atomic>
   
6. #include <mutex>
   
7. 
   
8. 
   
9. class Message
   
10. {
    
11. private:
    
12.     std::string m_data;
    
13. public:
    
14.     Message(std::string d);
    
15.     const std::string& data();
    
16. };
    
17. 
    
18. Message::Message(std::string d) : m_data(d)
    
19. {
    
20. }
    
21. 
    
22. const std::string& Message::data(){
    
23.     return m_data;
    
24. }
    
25. 
    
26. std::list<Message> global_message_list;  //所有stl中的容器都是线程不安全的
    
27. std::mutex global_mutex;
    
28. std::atomic<bool> ready(false);  //原子操作变量
    
29. std::atomic<bool> quit(false);
    
30. 
    
31. 
    
32. void worker(int i){
    
33.     while(!ready){
    
34.         //没有准备好 就在循环中等待
    
35.     }
    
36.     while(!quit){  // 不退出
    
37.         std::lock_guard<std::mutex> lock(global_mutex);  //利用lock对象的构造与自动析构
    
38.         if(global_message_list.empty()){
    
39.             continue;
    
40.         }
    
41.         auto iter = global_message_list.begin();
    
42.         //do real work and erase it!
    
43.         global_message_list.erase(iter);
    
44. 
    
45.     }
    
46. }
    
47. 
    
48. 
    
49. // real        0m11.248s
    
50. // user        0m0.297s
    
51. // sys        0m0.568s
    
52. 
    
53. // 发现：多线程比单线程的程序耗时还要多，原因何在？
    
54. // 1、锁用得过于频繁
    
55. 
    
56. int main(){
    
57.     // 数据的准备工作
    
58.     for(int i=0;i<10000;++i){
    
59.         global_message_list.push_back("this is a test"+std::to_string(i));
    
60.     }
    
61.     // 创建多个线程来干活
    
62.     const int threadCount = 4;
    
63.     std::vector<std::thread> pool;
    
64.     for(int i=0;i<threadCount;i++){
    
65.         //pool.emplace_back(worker, i);
    
66.         // 创建线程 非lambda函数方式
    
67.         pool.emplace_back(std::thread(worker, i));
    
68.     }
    
69.     // 主线程给 每个子线程的 一个信号(命令):准备干活了
    
70.     ready = true;
    
71.    
    
72.     // 主线程往全局list放数据
    
73.     for(int i=0;i<10000;++i){
    
74.         std::lock_guard<std::mutex> lock(global_mutex);
    
75.         std::this_thread::sleep_for(std::chrono::milliseconds(1));
    
76.         global_message_list.push_back("the second "+std::to_string(i));
    
77.     }
    
78. 
    
79.     //quit=true;
    
80.     while (true)
    
81.     {
    
82.         std::lock_guard<std::mutex> lock(global_mutex);
    
83.         if(global_message_list.empty()){
    
84.             // 主线程 发信号给所有的子线程
    
85.             // 假设：所有子线程是要把活 全部干完的！
    
86.             quit=true;
    
87.             break;
    
88.         }
    
89.     }
    
90.    
    
91. 
    
92. 
    
93.     for(auto &v : pool){
    
94.         if(v.joinable()){
    
95.             v.join();
    
96.         }
    
97.     }
    
98. 
    
99.     std::cout << "主线程结束!" << std::endl;
    
100. 
     
101.     return 0;
     
102. }
     
103. 
     

复制代码