多线程编程：尽量减少锁空间

东方耀

多线程编程：尽量减少锁空间


//http://www.ai111.vip/thread-1247-1-1.html  继续改进 减少锁空间
// 多线程编程：尽量减少锁空间

1. #include <iostream>
   
2. #include <list>
   
3. #include <vector>
   
4. #include <thread>
   
5. #include <atomic>
   
6. #include <mutex>
   
7. #include <cstring>
   
8. #include <string>
   
9. 
   
10. 
    
11. class Message
    
12. {
    
13. private:
    
14.     std::string m_data;
    
15. public:
    
16.     Message(std::string d);
    
17.     const std::string& data();
    
18. };
    
19. 
    
20. Message::Message(std::string d=std::string()) : m_data(d)
    
21. {
    
22. }
    
23. 
    
24. const std::string& Message::data(){
    
25.     return m_data;
    
26. }
    
27. 
    
28. std::list<Message> global_message_list;  //所有stl中的容器都是线程不安全的
    
29. std::mutex global_mutex;
    
30. std::atomic<bool> ready(false);  //原子操作变量
    
31. std::atomic<bool> quit(false);
    
32. std::atomic<int> total_size(0);
    
33. 
    
34. //http://www.ai111.vip/thread-1247-1-1.html  继续改进 减少锁空间
    
35. // 多线程编程：尽量减少锁空间
    
36. 
    
37. 
    
38. void worker(int i){
    
39.     while(!ready){
    
40.         //没有准备好 就在循环中等待
    
41.     }
    
42.     while(!quit){  // 不退出
    
43.         //std::this_thread::sleep_for(std::chrono::milliseconds(1));
    
44.         Message msg;
    
45.         {   
    
46.             //将锁空间 尽量压缩在这块代码内
    
47.             std::lock_guard<std::mutex> lock(global_mutex);  //利用lock对象的构造与自动析构
    
48.             if(global_message_list.empty()){
    
49.                 continue;
    
50.             }
    
51.             auto iter = global_message_list.begin();
    
52.             msg = std::move(*iter);  // move是干啥的？
    
53.             global_message_list.erase(iter);
    
54.         }
    
55.         //do real work and erase it!  干的工作：计算字符串的长度并求和
    
56.         //真正干活的 有atomic原子操作 所以不需要 临界区mutex加锁了
    
57.         total_size += strlen(msg.data().c_str());
    
58. 
    
59.     }
    
60. }
    
61. 
    
62. 
    
63. // real        0m11.248s
    
64. // user        0m0.297s
    
65. // sys        0m0.568s
    
66. 
    
67. // 发现：多线程比单线程的程序耗时还要多，原因何在？
    
68. // 1、锁用得过于频繁    伪多线程
    
69. 
    
70. int main(){
    
71.     // 数据的准备工作
    
72.     for(int i=0;i<10000;++i){
    
73.         global_message_list.push_back("this is a test"+std::to_string(i));
    
74.     }
    
75. 
    
76.     // 创建多个线程来干活
    
77.     const int threadCount = 4;
    
78.     std::vector<std::thread> pool;
    
79.     for(int i=0;i<threadCount;i++){
    
80.         //pool.emplace_back(worker, i);
    
81.         // 创建线程 非lambda函数方式
    
82.         pool.emplace_back(std::thread(worker, i));
    
83.     }
    
84.     // 主线程给 每个子线程的 一个信号(命令):准备干活了
    
85.     ready = true;
    
86.    
    
87.     // 主线程往全局list放数据
    
88.     for(int i=0;i<10000;++i){
    
89.         std::this_thread::sleep_for(std::chrono::milliseconds(1));
    
90.         // 减少锁空间
    
91.         std::lock_guard<std::mutex> lock(global_mutex);
    
92.         global_message_list.push_back("the second "+std::to_string(i));
    
93.     }
    
94. 
    
95.     //quit=true;
    
96.     while (true)
    
97.     {
    
98.         std::lock_guard<std::mutex> lock(global_mutex);
    
99.         if(global_message_list.empty()){
    
100.             // 主线程 发信号给所有的子线程
     
101.             // 假设：所有子线程是要把活 全部干完的！
     
102.             quit=true;
     
103.             break;
     
104.         }
     
105.     }
     
106.    
     
107. 
     
108. 
     
109.     for(auto &v : pool){
     
110.         if(v.joinable()){
     
111.             v.join();
     
112.         }
     
113.     }
     
114. 
     
115.     std::cout << "主线程结束!" << std::endl;
     
116.     std::cout << "统计所有字符串的总长度=" << total_size << std::endl;
     
117. 
     
118. //     统计所有字符串的总长度=327780
     
119. 
     
120. // real        0m10.843s
     
121. // user        0m13.613s
     
122. // sys        0m25.811s
     
123. 
     
124. 
     
125.     return 0;
     
126. }
     
127. 
     

复制代码

zouqiqi

让天下人人学会人工智能！人工智能的前景一片大好！