多线程共享变量解决2：原子操作atomic

东方耀

// 问题抛出：多线程的坑，使用了共享变量
// http://www.ai111.vip/thread-1242-1-1.html
//解决1、三个线程共享了资源，把共享去掉即可 比较高效与简单的方法
//如果可能，必须要用的方法 不使用共享变量就可以了 多定义一下变量即可啊 最后汇总
// 原则：如果没有必要，线程间不要共享资源


//解决2：如果一定要使用共享变量呢？咋办？   从共享变量作文章  原子操作atomic
//std::atomic<int>
//还是会有问题：变量都是原子操作的变量，但是如果多个组合起来又未必是原子操作了！


//多线程共享变量解决2：原子操作atomic

1. #include <iostream>
   
2. //#include <boost/thread/thread.hpp>
   
3. #include <thread>
   
4. #include <vector>
   
5. #include <atomic>
   
6. 
   
7. 
   
8. 
   
9. class Counter{
   
10. public:
    
11.     Counter() : m_count(0) {}
    
12.     void addCount() {m_count++;}   //从内存到寄存器 寄存器加1 写回内存
    
13.     int count() const {return m_count;}
    
14. private:
    
15.     //int m_count;
    
16.     std::atomic<int> m_count;    //原子操作变量类型  3个操作合并最小单元的原子操作
    
17.     // 原子操作的int类型
    
18. };
    
19. 
    
20. int work(int a){
    
21.     //do something
    
22.     return a + a;
    
23. }
    
24. 
    
25. 
    
26. template <typename Iter>
    
27. void real_work(Counter& c, double& total_value, Iter b, Iter e){
    
28.     for(;b!=e;++b){
    
29.         total_value += work(*b);
    
30.         c.addCount();
    
31.     }
    
32. }
    
33. 
    
34. bool is_work_finished(Counter& c, int max_times){
    
35.     if(c.count() >= max_times){
    
36.         std::cout << "work工作已经完成啦！\n" << std::endl;
    
37.         return true;
    
38.     }
    
39.     //std::cout << "work工作_没有完成呢" << std::endl;
    
40.     return false;
    
41. }
    
42. 
    
43. 
    
44. 
    
45. int main(){
    
46. 
    
47.     std::cout << "最大并发数=" << std::thread::hardware_concurrency() << std::endl;
    
48.     // Counter c1;
    
49.     // std::cout << c1.count()<< std::endl;
    
50.     // c1.addCount();
    
51.     // c1.addCount();
    
52.     // std::cout << c1.count()<< std::endl;
    
53.     std::vector<int> vec;
    
54.     for(int i=0;i<10000000;++i){
    
55.         vec.push_back(rand() % 100);
    
56.     }
    
57.     //没跑一次的时候来计数
    
58.     Counter c1;
    
59.     double total_value = 0.0f;
    
60.     for(auto v : vec){
    
61.         total_value += work(v);
    
62.         c1.addCount();
    
63.     }
    
64.     std::cout << "计数器的执行次数=" << c1.count() << "结果=" << total_value << std::endl;
    
65. 
    
66.     //开多线程来做同样的工作   三个线程都会去操作的对象：c2和total_value 共享变量
    
67.     Counter c2;
    
68.     total_value = 0.0f;
    
69.     auto iter1 = vec.begin() + (vec.size() / 3);
    
70.     auto iter2 = vec.begin() + (vec.size() / 3 * 2);
    
71. 
    
72.     //开一个子线程 后台服务  一定要使用共享变量c2
    
73.     //问题在这里：线程之间如何保证数据是一致的？
    
74.     std::thread service_back([&c2](){
    
75.         while (!is_work_finished(c2, 10000000))
    
76.         {
    
77.             /* 当返回true的时候 该线程才算执行完毕 否则死循环里 */
    
78.         }
    
79.         
    
80.     });
    
81.     //一共三个线程  主线程 子线程t1 子线程t2  
    
82.     // lambda函数？  知识盲区
    
83.     // 引用传进去：c2 total_value
    
84.     // 作为值传进去：两个迭代器
    
85.     std::thread t1([&c2,&total_value,iter1,iter2](){
    
86.         real_work(c2,total_value,iter1,iter2);
    
87.     });
    
88.     auto end = vec.end();
    
89.     std::thread t2([&c2,&total_value,iter2,end](){
    
90.         real_work(c2,total_value,iter2,end);
    
91.     });
    
92. 
    
93. 
    
94.     //主线程里 做第一区间的  
    
95.     real_work(c2,total_value,vec.begin(),iter1);
    
96. 
    
97.     t1.join();
    
98.     t2.join();
    
99.     std::cout << "multithread_计数器的执行次数=" << c2.count() << "结果=" << total_value << std::endl;
    
100.     service_back.join();
     
101.     return 0;
     
102. }
     

复制代码

yj_jimmy

不断充实自己，不断解放自己