多线程的条件变量，避免CPU空转：wait、notify_one、unique_lock

东方耀

多线程的条件变量，避免CPU空转：wait、notify_one、unique_lock




#include <condition_variable>
条件变量：子线程可以更好的等待，避免cpu空转，提高性能效率
unique_lock是与条件变量一起使用的
unique_lock可以在中间过程中释放锁 而lock_guard做不到




http://www.ai111.vip/thread-1248-1-1.html 基础上改进

多线程编程中为啥这么多的锁？
std::lock_guard<std::mutex> lock(m_mutex);  //利用lock对象的构造与自动析构
std::unique_lock<std::mutex> lock(m_mutex);  // 与条件变量配合使用 避免CPU空转

typedef boost::unique_lock<boost::mutex> scoped_lock;
boost::lock_guard<boost::shared_mutex> guard(m_mutex);
boost::shared_lock<boost::shared_mutex> guard(m_mutex);

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. #include <condition_variable>
   
10. 
    
11. 
    
12. class Message
    
13. {
    
14. private:
    
15.     std::string m_data;
    
16. public:
    
17.     Message(std::string d);
    
18.     const std::string& data();
    
19. };
    
20. 
    
21. Message::Message(std::string d=std::string()) : m_data(d)
    
22. {
    
23. }
    
24. 
    
25. const std::string& Message::data(){
    
26.     return m_data;
    
27. }
    
28. 
    
29. std::list<Message> global_message_list;  //所有stl中的容器都是线程不安全的
    
30. std::mutex global_mutex;
    
31. std::atomic<bool> ready(false);  //原子操作变量
    
32. std::atomic<bool> quit(false);
    
33. std::atomic<int> total_size(0);
    
34. 
    
35. std::condition_variable cv;
    
36. 
    
37. //http://www.ai111.vip/thread-1247-1-1.html  继续改进 减少锁空间
    
38. // 多线程编程：尽量减少锁空间
    
39. 
    
40. // 条件变量：子线程可以更好的等待，避免cpu空转，提高性能效率
    
41. 
    
42. 
    
43. void worker(int i){
    
44.     while(!ready){
    
45.         //没有准备好 就在循环中等待
    
46.     }
    
47.     Message msg;
    
48.     while(!quit){  // 不退出
    
49.         //std::this_thread::sleep_for(std::chrono::milliseconds(1));
    
50.         
    
51.         {   
    
52.             //将锁空间 尽量压缩在这块代码内
    
53.             //std::lock_guard<std::mutex> lock(global_mutex);  //利用lock对象的构造与自动析构
    
54.             // unique_lock是与条件变量一起使用的
    
55.             std::unique_lock<std::mutex> lock(global_mutex);
    
56.             // 等待的过程中 把锁绑定的mutex释放掉 是不加锁的
    
57.             // unique_lock可以在中间过程中释放锁 而lock_guard做不到
    
58.             // 等待 lambda函数里的条件 达成 就被唤醒
    
59.             cv.wait(lock, [](){
    
60.                 //要么是 要退出 或 消息队列不为空
    
61.                 return quit || !global_message_list.empty();
    
62.             });
    
63.             if(quit){
    
64.                 return;
    
65.             }
    
66.             auto iter = global_message_list.begin();
    
67.             msg = std::move(*iter);
    
68.             //std ::move是将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存的搬迁或者内存拷贝
    
69.             global_message_list.erase(iter);
    
70.         }
    
71.         //do real work and erase it!  干的工作：计算字符串的长度并求和
    
72.         //真正干活的 有atomic原子操作 所以不需要 临界区mutex加锁了
    
73.         total_size += strlen(msg.data().c_str());
    
74. 
    
75.     }
    
76. }
    
77. 
    
78. 
    
79. // 发现：多线程比单线程的程序耗时还要多，原因何在？
    
80. // 1、锁用得过于频繁    伪多线程
    
81. 
    
82. int main(){
    
83.     // 数据的准备工作
    
84.     for(int i=0;i<10000;++i){
    
85.         global_message_list.push_back("this is a test"+std::to_string(i));
    
86.     }
    
87. 
    
88.     // 创建多个线程来干活
    
89.     const int threadCount = 4;
    
90.     std::vector<std::thread> pool;
    
91.     for(int i=0;i<threadCount;i++){
    
92.         //pool.emplace_back(worker, i);
    
93.         // 创建线程 非lambda函数方式
    
94.         pool.emplace_back(std::thread(worker, i));
    
95.     }
    
96.     // 主线程给 每个子线程的 一个信号(命令):准备干活了
    
97.     ready = true;
    
98.    
    
99.     // 主线程往全局list放数据
    
100.     for(int i=0;i<10000;++i){
     
101.         std::this_thread::sleep_for(std::chrono::milliseconds(1));
     
102.         {
     
103.             // 减少锁空间
     
104.             std::lock_guard<std::mutex> lock(global_mutex);
     
105.             global_message_list.push_back("the second "+std::to_string(i));
     
106.         }
     
107.         // 关键代码：每放一个新元素就通知一个子线程  与 cv.wait()对应的
     
108.         cv.notify_one();
     
109.         // global_message_list中没有元素就等待 有元素才运行 极大避免CPU空转
     
110.     }
     
111. 
     
112.     //quit=true;
     
113.     while (true)
     
114.     {
     
115.         std::lock_guard<std::mutex> lock(global_mutex);
     
116.         if(global_message_list.empty()){
     
117.             // 主线程 发信号给所有的子线程
     
118.             // 假设：所有子线程是要把活 全部干完的！
     
119.             quit=true;
     
120.             cv.notify_all();   //全部唤醒子线程  与 cv.wait()对应的
     
121.             break;
     
122.         }
     
123.     }
     
124.    
     
125. 
     
126. 
     
127.     for(auto &v : pool){
     
128.         if(v.joinable()){
     
129.             v.join();
     
130.         }
     
131.     }
     
132. 
     
133.     std::cout << "主线程结束!" << std::endl;
     
134.     std::cout << "统计所有字符串的总长度=" << total_size << std::endl;
     
135. 
     
136. //     统计所有字符串的总长度=327780
     
137. 
     
138. // real        0m10.843s
     
139. // user        0m13.613s
     
140. // sys        0m25.811s
     
141. 
     
142. // 主线程结束!
     
143. // 统计所有字符串的总长度=327780
     
144. 
     
145. // real        0m11.235s
     
146. // user        0m0.475s
     
147. // sys        0m0.486s
     
148. 
     
149. 
     
150.     return 0;
     
151. }
     
152. 
     

复制代码

zouqiqi

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