【C++ 多线程机制】shared_mutex 解析

 shared_mutex 解析

 1. 示例

  1 #include 
  2 #include 
  3 #include 
  4 #include 
  5 #include 
  6 #include 
  7 
  8 #define READ_THREAD_COUNT 8
  9 #define LOOP_COUNT 5000000
 10 
 11 typedef std::shared_lock ReadLock;
 12 typedef std::lock_guard WriteLock;
 13 typedef std::lock_guard NormalLock;
 14 
 15 class shared_mutex_counter
 16 {
 17 public:
 18     shared_mutex_counter() = default;
 19 
 20     unsigned int get() const
 21     {
 22         ReadLock lock(mutex);
 23         return value;
 24     }
 25 
 26     void increment()
 27     {
 28         WriteLock lock(mutex);
 29         value++;
 30     }
 31 
 32 private:
 33     mutable std::shared_mutex mutex;
 34     unsigned int value = 0;
 35 };
 36 
 37 class mutex_counter
 38 {
 39 public:
 40     mutex_counter() = default;
 41 
 42     unsigned int get() const
 43     {
 44         NormalLock lock(mutex);
 45         return value;
 46     }
 47 
 48     void increment()
 49     {
 50         NormalLock lock(mutex);
 51         value++;
 52     }
 53 
 54 private:
 55     mutable std::mutex mutex;
 56     unsigned int value = 0;
 57 };
 58 
 59 class timers
 60 {
 61 public:
 62     timers()
 63     {
 64         m_begin = std::chrono::high_resolution_clock::now();
 65     }
 66 
 67     ~timers()
 68     {
 69         m_end = std::chrono::high_resolution_clock::now();
 70         Consuming();
 71     }
 72 
 73     void Consuming()
 74     {
 75         std::cout << "Time-consuming:" 
 76                             << std::chrono::duration_castfloat, std::milli>>(m_end - m_begin).count() 
 77                             << std::endl;
 78     }
 79 
 80 private:
 81     std::chrono::high_resolution_clock::time_point m_begin;
 82     std::chrono::high_resolution_clock::time_point m_end;
 83 };
 84 
 85 void test_shared_mutex()
 86 {
 87     shared_mutex_counter counter;
 88     unsigned int temp;
 89 
 90     auto writer = [&counter]() {
 91         for (unsigned int i = 0; i < LOOP_COUNT; i++)
 92         {
 93             counter.increment();
 94         }
 95     };
 96 
 97     auto reader = [&counter, &temp]() {
 98         for (unsigned int i = 0; i < LOOP_COUNT; i++)
 99         {
100             temp = counter.get();
101         }
102     };
103 
104     std::cout << "----- shared mutex test ------" << std::endl;
105     std::list> threadlist;
106     {
107         timers timer;
108 
109         for (int i = 0; i < READ_THREAD_COUNT; i++)
110         {
111             threadlist.push_back(std::make_shared(reader));
112         }
113         std::shared_ptr pw = std::make_shared(writer);
114 
115         for (auto &it : threadlist)
116         {
117             it->join();
118         }
119         pw->join();
120     }
121     std::cout << "count:" << counter.get() << ", temp:" << temp << std::endl;
122 }
123 
124 void test_mutex()
125 {
126     mutex_counter counter;
127     unsigned int temp;
128 
129     auto writer = [&counter]() {
130         for (unsigned int i = 0; i < LOOP_COUNT; i++)
131         {
132             counter.increment();
133         }
134     };
135 
136     auto reader = [&counter, &temp]() {
137         for (unsigned int i = 0; i < LOOP_COUNT; i++)
138         {
139             temp = counter.get();
140         }
141     };
142 
143     std::cout << "----- mutex test ------" << std::endl;
144     std::list> threadlist;
145     {
146         timers timer;
147 
148         for (int i = 0; i < READ_THREAD_COUNT; i++)
149         {
150             threadlist.push_back(std::make_shared(reader));
151         }
152 
153         std::shared_ptr pw = std::make_shared(writer);
154 
155         for (auto &it : threadlist)
156         {
157             it->join();
158         }
159         pw->join();
160     }
161     std::cout << "count:" << counter.get() << ", temp:" << temp << std::endl;
162 }
163 
164 int main()
165 {
166     test_shared_mutex();
167     test_mutex();
168     return 0;
169 }

shared_mutex 解析