问题抛出：多线程的坑，使用了共享变量

东方耀

问题抛出：多线程的坑，使用了共享变量

1. #include <iostream>
   
2. //#include <boost/thread/thread.hpp>
   
3. #include <thread>
   
4. #include <vector>
   
5. 
   
6. // 问题抛出：多线程的坑，使用了共享变量
   
7. 
   
8. class Counter{
   
9. public:
   
10.     Counter() : m_count(0) {}
    
11.     void addCount() {m_count++;}
    
12.     int count() const {return m_count;}
    
13. private:
    
14.     int m_count;
    
15. };
    
16. 
    
17. int work(int a){
    
18.     //do something
    
19.     return a + a;
    
20. }
    
21. 
    
22. 
    
23. template <typename Iter>
    
24. void real_work(Counter& c, double& total_value, Iter b, Iter e){
    
25.     for(;b!=e;++b){
    
26.         total_value += work(*b);
    
27.         c.addCount();
    
28.     }
    
29. }
    
30.     // auto real_work = [&c2, &total_value](auto b, auto e){
    
31.     //     for(;b!=e;++b){
    
32.     //         total_value += work(*b);
    
33.     //         c2.addCount();
    
34.     //     }
    
35.     // };
    
36. 
    
37. 
    
38. int main(){
    
39. 
    
40.     std::cout << "最大并发数=" << std::thread::hardware_concurrency() << std::endl;
    
41.     // Counter c1;
    
42.     // std::cout << c1.count()<< std::endl;
    
43.     // c1.addCount();
    
44.     // c1.addCount();
    
45.     // std::cout << c1.count()<< std::endl;
    
46.     std::vector<int> vec;
    
47.     for(int i=0;i<10000000;++i){
    
48.         vec.push_back(rand() % 100);
    
49.     }
    
50.     //没跑一次的时候来计数
    
51.     Counter c1;
    
52.     double total_value = 0.0f;
    
53.     for(auto v : vec){
    
54.         total_value += work(v);
    
55.         c1.addCount();
    
56.     }
    
57.     std::cout << "计数器的执行次数=" << c1.count() << "结果=" << total_value << std::endl;
    
58. 
    
59.     //开多线程来做同样的工作   三个线程都会去操作的对象：c2和total_value 共享变量
    
60.     Counter c2;
    
61.     total_value = 0.0f;
    
62.     auto iter1 = vec.begin() + (vec.size() / 3);
    
63.     auto iter2 = vec.begin() + (vec.size() / 3 * 2);
    
64.     //一共三个线程  主线程 子线程t1 子线程t2  
    
65.     // lambda函数？  知识盲区
    
66.     // 引用传进去：c2 total_value
    
67.     // 作为值传进去：两个迭代器
    
68.     std::thread t1([&c2,&total_value,iter1,iter2]{
    
69.         real_work(c2,total_value,iter1,iter2);
    
70.     });
    
71.     auto end = vec.end();
    
72.     std::thread t2([&c2,&total_value,iter2,end]{
    
73.         real_work(c2,total_value,iter2,end);
    
74.     });
    
75.     //主线程里 做第一区间的  
    
76.     real_work<std::vector<int>::iterator>(c2,total_value,vec.begin(),iter1);
    
77.     // for(auto iter=vec.begin(); iter!=iter1; iter++){
    
78.     //     total_value += work(*iter);
    
79.     //     c2.addCount();
    
80.     // }
    
81. 
    
82.     t1.join();
    
83.     t2.join();
    
84. 
    
85.     std::cout << "multithread_计数器的执行次数=" << c2.count() << "结果=" << total_value << std::endl;
    
86. 
    
87. 
    
88. 
    
89.    
    
90.     return 0;
    
91. }

复制代码

东方耀

1. cmake_minimum_required (VERSION 2.8)
   
2. project (main)
   
3. 
   
4. #SET(CMAKE_CXX_STANDARD 11)
   
5. #SET(CMAKE_C_STANDARD 11)
   
6. 
   
7. #aux_source_directory(. ALL_SRCS)                        # 添加当前目录下所有的源文件
   
8. set(ALL_SRCS "17_std_thread.cpp")
   
9. #add_subdirectory(lib)                                                # 添加lib子目录
   
10. add_executable(main ${ALL_SRCS})        # 指定生成目标，注意这里要用${ALL_SRCS}!!!
    
11. message(WARNING "我说：lib目录里的文件编译成动态库再由main函数调用")
    
12. #target_link_libraries(main power)        # 添加链接库，power是在lib子目录的CMakeLists中定义的
    
13. 
    
14. find_package(FFTW3f)
    
15. target_link_libraries(main -lboost_system -lboost_thread -lfftw3f -lpthread)

复制代码

东方耀

1. #include <iostream>
   
2. //#include <boost/thread/thread.hpp>
   
3. #include <thread>
   
4. #include <vector>
   
5. 
   
6. //解决1、三个线程共享了资源，把共享去掉即可 比较高效与简单的方法
   
7. //如果可能，必须要用的方法 不使用共享变量就可以了 多定义一下变量即可啊 最后汇总
   
8. // 原则：如果没有必要，线程间不要共享资源
   
9. 
   
10. class Counter{
    
11. public:
    
12.     Counter() : m_count(0) {}
    
13.     void addCount() {m_count++;}
    
14.     int count() const {return m_count;}
    
15. private:
    
16.     int m_count;
    
17. };
    
18. 
    
19. int work(int a){
    
20.     //do something
    
21.     return a + a;
    
22. }
    
23. 
    
24. 
    
25. template <typename Iter>
    
26. void real_work(Counter& c, double& total_value, Iter b, Iter e){
    
27.     for(;b!=e;++b){
    
28.         total_value += work(*b);
    
29.         c.addCount();
    
30.     }
    
31. }
    
32. 
    
33. 
    
34. int main(){
    
35. 
    
36.     std::cout << "最大并发数=" << std::thread::hardware_concurrency() << std::endl;
    
37.     // Counter c1;
    
38.     // std::cout << c1.count()<< std::endl;
    
39.     // c1.addCount();
    
40.     // c1.addCount();
    
41.     // std::cout << c1.count()<< std::endl;
    
42.     std::vector<int> vec;
    
43.     for(int i=0;i<10000000;++i){
    
44.         vec.push_back(rand() % 100);
    
45.     }
    
46.     //没跑一次的时候来计数
    
47.     Counter c1;
    
48.     double total_value = 0.0f;
    
49.     for(auto v : vec){
    
50.         total_value += work(v);
    
51.         c1.addCount();
    
52.     }
    
53.     std::cout << "计数器的执行次数=" << c1.count() << "结果=" << total_value << std::endl;
    
54. 
    
55.     //开多线程来做同样的工作   三个线程都会去操作的对象：c2和total_value 共享变量
    
56.     Counter c2,c3,c4;
    
57.     total_value = 0.0f;
    
58.     double total_value1 = 0.0f;
    
59.     double total_value2 = 0.0f;
    
60.     auto iter1 = vec.begin() + (vec.size() / 3);
    
61.     auto iter2 = vec.begin() + (vec.size() / 3 * 2);
    
62.     //一共三个线程  主线程 子线程t1 子线程t2  
    
63.     // lambda函数？  知识盲区
    
64.     // 引用传进去：c2 total_value
    
65.     // 作为值传进去：两个迭代器
    
66.     std::thread t1([&c3,&total_value1,iter1,iter2]{
    
67.         real_work(c3,total_value1,iter1,iter2);
    
68.     });
    
69.     auto end = vec.end();
    
70.     std::thread t2([&c4,&total_value2,iter2,end]{
    
71.         real_work(c4,total_value2,iter2,end);
    
72.     });
    
73.     //主线程里 做第一区间的  
    
74.     real_work<std::vector<int>::iterator>(c2,total_value,vec.begin(),iter1);
    
75.     // for(auto iter=vec.begin(); iter!=iter1; iter++){
    
76.     //     total_value += work(*iter);
    
77.     //     c2.addCount();
    
78.     // }
    
79. 
    
80.     t1.join();
    
81.     t2.join();
    
82. 
    
83.     std::cout << "multithread_计数器的执行次数=" << c2.count()+c3.count()+c4.count() << "结果=" << total_value+total_value1+total_value2 << std::endl;
    
84.    
    
85.     return 0;
    
86. }

复制代码

yj_jimmy

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

zouqiqi

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