UI操作 解决方案

  1 #include <iostream>                                                                                                                                                                                                          
  2 #include <deque>                                                                                                                                                                                                             
  3 #include <mutex>                                                                                                                                                                                                             
  4 #include <future>                                                                                                                                                                                                            
  5 #include <thread>                                                                                                                                                                                                            
  6 #include <utility>                                                                                                                                                                                                           
  7                                                                                                                                                                                                                              
  8                                                                                                                                                                                                                              
  9 std::mutex m;                                                                                                                                                                                                                
 10 std::deque<std::packaged_task<void()> > tasks;                                                                                                                                                                               
 11                                                                                                                                                                                                                              
 12 bool gui_shutdown_message_received();                                                                                                                                                                                        
 13 void get_and_process_gui_message();                                                                                                                                                                                          
 14                                                                                                                                                                                                                              
 15 void gui_thread()                                                                                                                                                                                                            
 16 {                                                                                                                                                                                                                            
 17     while(!gui_shutdown_message_received())                                                                                                                                                                                  
 18     {                                                                                                                                                                                                                        
 19         get_and_process_gui_message();                                                                                                                                                                                       
 20         std::packaged_task<void()> task;                                                                                                                                                                                     
 21         {                                                                                                                                                                                                                    
 22             std::lock_guard<std::mutex> lk(m);                                                                                                                                                                               
 23             if(tasks.empty())                                                                                                                                                                                                
 24                 continue;                                                                                                                                                                                                    
 25                                                                                                                                                                                                                              
 26             task = std::move(tasks.front());                                                                                                                                                                                 
 27             tasks.pop_front();                                                                                                                                                                                               
 28         }                                                                                                                                                                                                                    
 29         task();                                                                                                                                                                                                              
 30     }                                                                                                                                                                                                                        
 31 }                                                                                                                                                                                                                            
 32                                                                                                                                                                                                                              
 33 std::thread gui_bg_thread(gui_thread);                                                                                                                                                                                       
 34                                                                                                                                                                                                                              
 35 template<typename Func>                                                                                                                                                                                                      
 36 std::future<void> post_task_for_gui_thread(Func f)                                                                                                                                                                           
 37 {                                                                                                                                                                                                                            
 38     std::packaged_task<void()> task(f);                                                                                                                                                                                      
 39     std::future<void> res = task.get_future();                                                                                                                                                                               
 40     std::lock_guard<std::mutex> lk(m);                                                                                                                                                                                       
 41     tasks.push_back(std::move(task));                                                                                                                                                                                        
 42     return res;                                                                                                                                                                                                              
 43 }                                                                                                                                                                                                                            
 44                                                                                                                                                                                                                              
 45                                                                                                                                                                                                                              
 46 int main(int argc,char** argv)                                                                                                                                                                                               
 47 {                                                                                                                                                                                                                            
 48     std::cout << "-------------------------------------------------------" << std::endl;                                                                                                                                     
 49                                                                                                                                                                                                                              
 50     return 0;                                                                                                                                                                                                                
 51 }                                                                                                                                                                                                                                                           
~