C++ std::bad_function_call 与 Segmentation Fault 同时出现

hellomyprogram

在我的代码中，如果保留 threads.cpp 第 46 行的 if (function) ，那么我的程序会突然无响应。
而如果删除的话，我的代码会报 Segmentation Fault 和 std::bad_function_call ，但是它们出现似乎是随机的，有的时候有，有的时候没有。
Minecraft for C.zip (5.58 KB, 下载次数: 3)

2023-8-3 16:20 上传

点击文件名下载附件
源代码

Segmentation Fault 错误出现在 main.cpp 的第 17 行。 std::bad_function_call 出现在 threads.cpp 的第 45 行。
请问这是为什么？又怎么解决？

--- 已解决 ---
问题出自内存泄漏，在 DistributeThread::run 下调用了 sleep 函数，但是 sleep 函数只接受整数，因此我输入的小数都被整型化为 0 ，因此 DistributeThread “疯了”，乱发任务，导致内存泄漏，在崩溃时刻，线程里的任务队列已经积攒到百万数量级。

isdkz

这种情况通常发生在多线程代码中，涉及了竞态条件（race condition）或者内存访问错误。Segmenation Fault 表示你的程序试图访问了无效的内存地址，而 std::bad_function_call 则表示你尝试调用一个空的 std::function 对象。

解决这个问题的步骤如下：

1. 调试 Segmentation Fault：
   · 确保你没有越界访问数组或者指针。
   · 确保没有在使用已释放的内存。
   · 确保没有使用空指针。
   · 使用工具如  valgrind  来检查内存错误。

2. 调试 std::bad_function_call：
   · 确保在调用 std::function 之前，该对象已经被正确地初始化。
   · 确保你没有在多个线程中同时修改或调用同一个 std::function 对象，可能需要使用互斥锁来保护。
   · 如果是从其他线程调用的 std::function，确保在调用之前该函数对象不会被销毁。

3. 处理竞态条件：
   · 使用互斥锁（mutex）来保护共享数据，确保每个线程在访问共享数据之前先锁定互斥锁，在访问完毕后解锁。
   · 考虑使用原子操作来进行简单的线程安全操作。

4. 使用调试工具：
   · 使用调试器（如 GDB）来逐步调试程序，查找问题所在。
   · 使用线程检测工具（如 Helgrind）来检测多线程代码中的问题。

5. 编写更健壮的代码：
   · 仔细设计多线程架构，避免竞态条件和死锁。
   · 使用智能指针等 RAII 技术来管理资源，避免内存泄漏。

在定位问题时，可以根据错误出现的条件和频率来排查。如果问题确实难以找到，可能需要更详细的代码和错误信息来进行深入分析。

学习编程中的Ben

问题分析

根据提供的代码文件和问题描述，出现 Segmentation Fault 和 std::bad_function_call 错误的位置分别在 main.cpp 的第 17 行和 threads.cpp 的第 45 行。这些错误似乎是随机出现的。

由于没有提供完整的代码，我无法直接定位问题的具体原因。但是可以给出一些可能导致这些错误的常见原因和解决方法。

解决方案

1. Segmentation Fault 错误：
   - 检查第 17 行代码附近的指针操作，确保指针有效，并且没有被释放、空指针解引用等问题。
   - 检查是否存在数组越界的情况，确保数组访问不超过合法范围。
   - 使用合适的内存管理技术，如智能指针（std::shared_ptr、std::unique_ptr）来避免内存泄漏和悬挂指针等问题。
   - 如果有多线程代码，请确保在访问共享资源时正确地进行同步，以避免竞态条件等问题。

2. std::bad_function_call 错误：
   - 检查第 45 行代码附近的函数对象使用，确保在调用函数对象之前，已经将有效的函数对象绑定到它上面。
   - 在使用函数对象之前，可以使用条件语句或者std::function::target来检查函数对象是否为空，避免调用无效的函数对象。
   - 确保函数签名匹配，避免调用时参数类型不匹配或者返回值类型不一致。

3. 除了以上的常见问题，还可能存在其他与特定代码相关的问题。这种情况下，需要仔细检查相关代码，进行逐行调试并使用调试器来跟踪程序执行过程，以找出错误发生的具体原因。

请注意，由于我无法直接查看并修改你上传的代码，以上解决方案只是根据常见问题给出的一般性建议。如果你能提供更多关于问题的上下文信息或相关的代码片段，我可以尝试提供更具体的帮助。

如果回答对你有帮助，请给我一个最佳答案！

hellomyprogram

完整代码如下：

1. // main.cpp
   
2. #include <SFML/Graphics.hpp>
   
3. #include "threads.h"
   
4. 
   
5. DistributeThread threads;
   
6. 
   
7. class Main
   
8. {
   
9.         public:
   
10.                 double view_direction[2] = {0, 0};
    
11.                 double player_position[3] = {0, 0, 0};
    
12.                 sf::RenderWindow *window = nullptr;
    
13.                 sf::RenderWindow *window_log = nullptr;
    
14.                 sf::Event event;
    
15. 
    
16.                 void control()
    
17.                 {
    
18.                         while (this->window->pollEvent(event))
    
19.                         {
    
20.                                 switch (event.type)
    
21.                                 {
    
22.                                         case sf::Event::KeyPressed:
    
23.                                                 if (event.key.control)
    
24.                                                 {
    
25.                                                         switch (event.key.code)
    
26.                                                         {
    
27.                                                                 case sf::Keyboard::L:
    
28.                                                                         if (this->window_log == nullptr)
    
29.                                                                         {
    
30.                                                                                 this->window_log->setVisible(true);
    
31.                                                                         }
    
32.                                                                         break;
    
33.                                                         };
    
34.                                                 };
    
35.                                                 break;
    
36.                                         case sf::Event::Closed:
    
37.                                                 this->window->close();
    
38.                                                 threads.stop();
    
39.                                                 break;
    
40.                                 };
    
41.                         };
    
42.                 };
    
43. 
    
44.                 void init()
    
45.                 {
    
46.                         this->window = new sf::RenderWindow(sf::VideoMode(1000, 1000), "Minecraft for C");
    
47.                         this->window_log = new sf::RenderWindow(sf::VideoMode(1000, 1000), "Minecraft for C");
    
48.                         this->window_log->setVisible(false);
    
49.                 };
    
50. };
    
51. 
    
52. int main()
    
53. {
    
54.         Main system;
    
55.         threads.work("Control", std::bind(Main::init, &system));
    
56.         threads.repeat_work("Control", 50, std::bind(Main::control, &system));
    
57.         if (threads.start())
    
58.         {
    
59.                 threads.join();
    
60.         };
    
61.         return 0;
    
62. };

复制代码

1. // math.cpp
   
2. #include <cmath>
   
3. #include "math.h"
   
4. #include "constants.hpp"
   
5. 
   
6. double radian(const double theta){
   
7.         return theta * (constants::pi / 180);
   
8. };
   
9. 
   
10. Matrix::Matrix(const Matrix &item) : Matrix(item.dimensions, item.values)
    
11. {};
    
12. 
    
13. Matrix::Matrix(Matrix &&item)
    
14. {
    
15.         this->dimensions[0] = item.dimensions[0];
    
16.         this->dimensions[1] = item.dimensions[1];
    
17.         this->values = item.values;       
    
18.         item.values = nullptr;
    
19. };
    
20. 
    
21. Matrix::Matrix(const unsigned short dimensions[2])
    
22. {
    
23.         this->dimensions[0] = dimensions[0];
    
24.         this->dimensions[1] = dimensions[1];
    
25.         this->values = new double[dimensions[0] * dimensions[1]]();
    
26. };
    
27. 
    
28. Matrix::Matrix(const unsigned short dimensions[2], const double *values) : Matrix(dimensions)
    
29. {
    
30.         for (unsigned int ptr_offset = 0; ptr_offset < dimensions[0] * dimensions[1]; ptr_offset++)
    
31.         {
    
32.                 *(this->values + ptr_offset) = *(values + ptr_offset);
    
33.         };
    
34. };
    
35. 
    
36. Matrix::~Matrix()
    
37. {
    
38.         if (this->values != nullptr)
    
39.         {
    
40.                 delete[] this->values;
    
41.         };
    
42. };
    
43. 
    
44. Matrix Matrix::operator+(const Matrix &other) const
    
45. {
    
46.         if (this->dimensions[0] != other.dimensions[0] || this->dimensions[1] != other.dimensions[1])
    
47.         {
    
48.                 throw errors::MatrixDimensionError();
    
49.         };
    
50.         Matrix result(*this);
    
51.         for (unsigned int ptr_offset = 0; ptr_offset < this->dimensions[0] * this->dimensions[1]; ptr_offset++)
    
52.         {
    
53.                 *(result.values + ptr_offset) += *(other.values + ptr_offset);
    
54.         };
    
55.         return result;
    
56. };
    
57. 
    
58. Matrix Matrix::operator+(const double other) const
    
59. {
    
60.         Matrix result(*this);
    
61.         for (unsigned int ptr_offset = 0; ptr_offset < this->dimensions[0] * this->dimensions[1]; ptr_offset++)
    
62.         {
    
63.                 *(result.values + ptr_offset) += other;
    
64.         };
    
65.         return result;
    
66. };
    
67. 
    
68. Matrix Matrix::operator-() const
    
69. {
    
70.         Matrix result(*this);
    
71.         for (unsigned int ptr_offset = 0; ptr_offset < this->dimensions[0] * this->dimensions[1]; ptr_offset++)
    
72.         {
    
73.                 *(result.values + ptr_offset) += -*(result.values + ptr_offset);
    
74.         };
    
75.         return result;
    
76. };
    
77. 
    
78. Matrix Matrix::operator-(const Matrix &other) const
    
79. {
    
80.         Matrix reversed = -other;
    
81.         return *this + reversed;
    
82. };
    
83. 
    
84. Matrix Matrix::operator-(const double other) const
    
85. {
    
86.         return *this + -other;
    
87. };
    
88. 
    
89. Matrix Matrix::operator*(const Matrix &other) const
    
90. {
    
91.         if (this->dimensions[1] != other.dimensions[0])
    
92.         {
    
93.                 throw errors::MatrixDimensionError();
    
94.         };
    
95.         unsigned short result_dimensions[2] = {this->dimensions[0], other.dimensions[1]};
    
96.         Matrix result(result_dimensions);
    
97.         int result_ptr_offset, this_ptr_offset, other_ptr_offset;
    
98.         for (short result_row = 0; result_row < result_dimensions[0]; result_row++)
    
99.         {
    
100.                 for (short result_column = 0; result_column < result_dimensions[1]; result_column++)
     
101.                 {
     
102.                         result_ptr_offset = result_row * result_dimensions[1] + result_column;
     
103.                         for (short index = 0; index < this->dimensions[1]; index++)
     
104.                         {
     
105.                                 this_ptr_offset = result_row * this->dimensions[1] + index;
     
106.                                 other_ptr_offset = index * other.dimensions[1] + result_column;
     
107.                                 *(result.values + result_ptr_offset) += *(this->values + this_ptr_offset) * *(other.values + other_ptr_offset);
     
108.                         };
     
109.                 };
     
110.         };
     
111.         return result;
     
112. };
     
113. 
     
114. Vector Matrix::operator*(const Vector &other) const
     
115. {
     
116.         unsigned short vector_matrix_dimensions[2] = {other.dimensions, 1};
     
117.         Matrix vector_matrix(vector_matrix_dimensions, other.values);
     
118.         Matrix result_matrix = *this * vector_matrix;
     
119.         Vector result = Vector(result_matrix.dimensions[0], result_matrix.values);
     
120.         return result;
     
121. };
     
122. 
     
123. Matrix Matrix::operator*(const double other) const
     
124. {
     
125.         Matrix result(*this);
     
126.         for (unsigned int ptr_offset = 0; ptr_offset < this->dimensions[0] * this->dimensions[1]; ptr_offset++)
     
127.         {
     
128.                 *(result.values + ptr_offset) *= other;
     
129.         };
     
130.         return result;
     
131. };
     
132. 
     
133. Matrix Matrix::operator/(const double other) const
     
134. {
     
135.         return *this * (1.0 / other);
     
136. };
     
137. 
     
138. Matrix Matrix::transpose() const
     
139. {
     
140.         Matrix result(this->dimensions);
     
141.         unsigned short row, column;
     
142.         for (unsigned int ptr_offset = 0; ptr_offset < this->dimensions[0] * this->dimensions[1]; ptr_offset++)
     
143.         {
     
144.                 row = ptr_offset / this->dimensions[1];
     
145.                 column = ptr_offset % this->dimensions[1];
     
146.                 *(result.values + column + row * this->dimensions[1]) = *(this->values + ptr_offset);
     
147.         };
     
148.         return result;
     
149. };
     
150. 
     
151. Vector::Vector(const Vector &item) : Vector(item.dimensions, item.values)
     
152. {};
     
153. 
     
154. Vector::Vector(const unsigned short dimensions, const double values[])
     
155. {
     
156.         this->dimensions = dimensions;
     
157.         this->values = new double[dimensions]();
     
158.         for (unsigned short index = 0; index < dimensions; index++)
     
159.         {
     
160.                 this->values[index] = values[index];
     
161.         };
     
162. };
     
163. 
     
164. Vector::Vector(Vector &&item)
     
165. {
     
166.         this->dimensions = item.dimensions;
     
167.         this->values = item.values;
     
168.         item.values = nullptr;
     
169. };
     
170. 
     
171. Vector::~Vector()
     
172. {
     
173.         if (this->values != nullptr)
     
174.         {
     
175.                 delete[] this->values;
     
176.         };
     
177. };
     
178. 
     
179. Vector Vector::operator+(const Vector &other) const
     
180. {
     
181.         if (this->dimensions != other.dimensions)
     
182.         {
     
183.                 throw errors::VectorDimensionError();
     
184.         };
     
185.         Vector result(*this);
     
186.         for (unsigned short index = 0; index < this->dimensions; index++)
     
187.         {
     
188.                 result.values[index] += other.values[index];
     
189.         };
     
190.         return result;
     
191. };
     
192. 
     
193. Vector Vector::operator+(const double other) const
     
194. {
     
195.         Vector result(*this);
     
196.         for (unsigned short index = 0; index < this->dimensions; index++)
     
197.         {
     
198.                 result.values[index] += other;
     
199.         };
     
200.         return result;
     
201. };
     
202. 
     
203. Vector Vector::operator-() const
     
204. {
     
205.         Vector result = *this;
     
206.         for (unsigned short index = 0; index < this->dimensions; index++)
     
207.         {
     
208.                 result.values[index] = -result.values[index];
     
209.         };
     
210.         return result;
     
211. };
     
212. 
     
213. Vector Vector::operator-(const Vector &other) const
     
214. {
     
215.         Vector reversed = -other;
     
216.         return *this + reversed;
     
217. };
     
218. 
     
219. Vector Vector::operator-(const double other) const
     
220. {
     
221.         return *this + -other;
     
222. };
     
223. 
     
224. Vector Vector::operator*(const Vector &other) const
     
225. {
     
226.         if (this->dimensions != 3 || other.dimensions != 3)
     
227.         {
     
228.                 throw errors::VectorDimensionError();
     
229.         };
     
230.         Vector result(*this);
     
231.         for (unsigned short index = 0; index < this->dimensions; index++)
     
232.         {
     
233.                 result.values[index] = this->values[(index + 1) % 3] * other.values[(index + 2) % 3] - this->values[(index + 2) % 3] * other.values[(index + 1) % 3];
     
234.         };
     
235.         return result;
     
236. };
     
237. 
     
238. Vector Vector::operator*(const double other) const
     
239. {
     
240.         Vector result(*this);
     
241.         for (unsigned short index = 0; index < this->dimensions; index++)
     
242.         {
     
243.                 result.values[index] *= other;
     
244.         };
     
245.         return result;
     
246. };
     
247. 
     
248. Vector Vector::operator/(const double other) const
     
249. {
     
250.         return *this * (1.0 / other);
     
251. };
     
252. 
     
253. double Vector::dot(const Vector &other) const
     
254. {
     
255.         if (this->dimensions != other.dimensions)
     
256.         {
     
257.                 throw errors::VectorDimensionError();
     
258.         };
     
259.         double result = 0;
     
260.         for (unsigned short index = 0; index < this->dimensions; index++)
     
261.         {
     
262.                 result += this->values[index] * other.values[index];
     
263.         };
     
264.         return result;
     
265. };
     
266. 
     
267. double Vector::length() const
     
268. {
     
269.         double result_squared = 0;
     
270.         for (unsigned short index = 0; index < this->dimensions; index++)
     
271.         {
     
272.                 result_squared += this->values[index] * this->values[index];
     
273.         };
     
274.         return sqrt(result_squared);
     
275. };
     
276. 
     
277. Vector Vector::length(const int scale) const
     
278. {
     
279.         return *this / (this->length() * scale);
     
280. };
     
281. 
     
282. double Vector::angle(const Vector &other) const
     
283. {
     
284.         return acos(this->dot(other) / (this->length() * other.length()));
     
285. };

复制代码

1. // threads.cpp
   
2. #include <unistd.h>
   
3. #include <iostream>
   
4. #include "threads.h"
   
5. 
   
6. BasicThread::BasicThread(const char* name)
   
7. {
   
8.         this->name.assign(name);
   
9.         this->state = choices::state_free;
   
10.         this->thread = new std::thread(&BasicThread::run, this);
    
11. };
    
12. 
    
13. choices::state BasicThread::get_state()
    
14. {
    
15.         return this->state;
    
16. };
    
17. 
    
18. [[nodiscard]]
    
19. std::unique_lock<std::mutex> * BasicThread::pause()
    
20. {
    
21.         this->state = choices::state_paused;
    
22.         std::unique_lock<std::mutex> *lock = new std::unique_lock<std::mutex>(this->mutex);
    
23.         return lock;
    
24. };
    
25. 
    
26. void BasicThread::resume(std::unique_lock<std::mutex> &lock)
    
27. {
    
28.         lock.unlock();
    
29.         this->alarm.notify_all();
    
30. };
    
31. 
    
32. void BasicThread::run()
    
33. {
    
34.         this->lock = new std::unique_lock<std::mutex>(this->mutex);
    
35.         this->lock->unlock();
    
36.         std::function<void ()> function;
    
37.         while (this->running)
    
38.         {
    
39.                 this->state = choices::state_running;
    
40.                 if (this->queue.empty())
    
41.                 {
    
42.                         this->sleep();
    
43.                 }
    
44.                 else
    
45.                 {
    
46.                         function = queue.front();
    
47.                         if (function)
    
48.                         function();
    
49.                         this->queue.pop();
    
50.                 };
    
51.         };
    
52.         delete this->lock;
    
53. };
    
54. 
    
55. void BasicThread::sleep()
    
56. {
    
57.         this->state = choices::state_free;
    
58.         this->alarm.wait(*this->lock);
    
59. };
    
60. 
    
61. void BasicThread::stop()
    
62. {
    
63.         this->running = false;
    
64.         this->alarm.notify_all();
    
65.         this->thread->join();
    
66.         this->state = choices::state_stopped;
    
67. };
    
68. 
    
69. void BasicThread::work(std::function<void ()> function)
    
70. {
    
71.         this->queue.push(function);
    
72.         this->alarm.notify_all();
    
73. };
    
74. 
    
75. BasicThread * DistributeThread::create(const char* name)
    
76. {
    
77.         std::string name_string = name;
    
78.         if (this->threads.find(name_string) != this->threads.end())
    
79.         {
    
80.                 throw errors::ThreadExistError();
    
81.         };
    
82.         BasicThread *new_thread = new BasicThread(name);
    
83.         this->threads[name_string] = new_thread;
    
84.         this->locks[name_string] = std::unique_lock<std::mutex>(new_thread->mutex);
    
85.         this->locks[name_string].unlock();
    
86.         return new_thread;
    
87. };
    
88. 
    
89. bool DistributeThread::start()
    
90. {
    
91.         if (this->plans.empty())
    
92.         {
    
93.                 return false;
    
94.         };
    
95.         this->thread = new std::thread(DistributeThread::run, this);
    
96.         return true;
    
97. };
    
98. 
    
99. BasicThread * DistributeThread::get(const char *thread_name)
    
100. {
     
101.         std::string thread_string = thread_name;
     
102.         if (this->threads.find(thread_string) == this->threads.end())
     
103.         {
     
104.                 return this->create(thread_name);
     
105.         }
     
106.         else
     
107.         {
     
108.                 return this->threads[thread_string];
     
109.         };
     
110. };
     
111. 
     
112. void DistributeThread::join()
     
113. {
     
114.         this->thread->join();
     
115. };
     
116. 
     
117. void DistributeThread::repeat_work(const char* thread_name, unsigned int delay, std::function<void ()> function)
     
118. {
     
119.         plan new_plan;
     
120.         new_plan.delay = delay;
     
121.         new_plan.function = function;
     
122.         new_plan.thread = this->get(thread_name);
     
123.         this->plans[last_id] = new_plan;
     
124.         this->queue.push(queue_item(delay, last_id));
     
125.         last_id++;
     
126. };
     
127. 
     
128. void DistributeThread::run()
     
129. {
     
130.         queue_item function;
     
131.         plan function_plan;
     
132.         while (this->running)
     
133.         {
     
134.                 function = this->queue.top();
     
135.                 if (function.first > this->game_time)
     
136.                 {
     
137.                         sleep((function.first - this->game_time) / 1000);  // Change milliseconds into seconds
     
138.                         this->game_time = function.first;
     
139.                         continue;
     
140.                 };
     
141.                 this->queue.pop();
     
142.                 function_plan = this->plans[function.second];
     
143.                 function_plan.thread->work(function_plan.function);
     
144.                 this->queue.push(queue_item(function.first + function_plan.delay, function.second));
     
145.         };
     
146. };
     
147. 
     
148. void DistributeThread::stop()
     
149. {
     
150.         this->running = false;
     
151.         for (auto iterator : this->threads)
     
152.         {
     
153.                 iterator.second->stop();
     
154.         };
     
155.         this->thread->join();
     
156. };
     
157. 
     
158. void DistributeThread::work(const char* thread_name, std::function<void ()> function)
     
159. {
     
160.         this->get(thread_name)->work(function);
     
161. };

复制代码

1. // math.h
   
2. #pragma once
   
3. 
   
4. double radian(const double);
   
5. 
   
6. class Vector
   
7. {
   
8.         public:
   
9.                 unsigned short dimensions = 0;
   
10.                 double *values = nullptr;
    
11. 
    
12.                 Vector(const Vector &);
    
13.                 Vector(Vector &&);
    
14.                 Vector(const unsigned short, const double []);
    
15.                 ~Vector();
    
16.                 Vector operator+(const Vector &) const;
    
17.                 Vector operator+(const double) const;
    
18.                 Vector operator-() const;
    
19.                 Vector operator-(const Vector &) const;
    
20.                 Vector operator-(const double) const;
    
21.                 Vector operator*(const Vector &) const;
    
22.                 Vector operator*(const double) const;
    
23.                 Vector operator/(const double) const;
    
24.                 double dot(const Vector &) const;
    
25.                 double length() const;
    
26.                 Vector length(const int) const;
    
27.                 double angle(const Vector &) const;
    
28. };
    
29. 
    
30. class Matrix
    
31. {
    
32.         public:
    
33.                 unsigned short dimensions[2] = {0, 0};
    
34.                 double *values = nullptr; // "*" creates a ptr pointing at an array with two dimensions.
    
35. 
    
36.                 Matrix(const Matrix &);
    
37.                 Matrix(Matrix &&);
    
38.                 Matrix(const unsigned short [2]);
    
39.                 Matrix(const unsigned short [2], const double *); // "*" is actually a ptr pointing at the first element of an array with two dimensions.
    
40.                 ~Matrix();
    
41.                 Matrix operator+(const Matrix &) const;
    
42.                 Matrix operator+(const double) const;
    
43.                 Matrix operator-() const;
    
44.                 Matrix operator-(const Matrix &) const;
    
45.                 Matrix operator-(const double) const;
    
46.                 Matrix operator*(const Matrix &) const;
    
47.                 Vector operator*(const Vector &) const;
    
48.                 Matrix operator*(const double) const;
    
49.                 Matrix operator/(const double) const;
    
50.                 Matrix transpose() const;
    
51. };

复制代码

1. // threads.h
   
2. #include <condition_variable>
   
3. #include <functional>
   
4. #include <thread>
   
5. #include <map>
   
6. #include <mutex>
   
7. #include <queue>
   
8. #include <unordered_map>
   
9. #include "constants.hpp"
   
10. 
    
11. class BasicThread
    
12. {
    
13.         friend class DistributeThread;
    
14.         public:
    
15.                 std::string name = "Basic";
    
16.                 BasicThread(const char*);
    
17.                 choices::state get_state();
    
18.                 std::unique_lock<std::mutex> * pause();
    
19.                 void resume(std::unique_lock<std::mutex> &);
    
20.                 void stop();
    
21.         protected:
    
22.                 std::condition_variable alarm;
    
23.                 std::unique_lock<std::mutex> *lock;
    
24.                 std::mutex mutex;
    
25.                 std::queue<std::function<void ()>> queue;
    
26.                 bool running = true;
    
27.                 choices::state state = choices::state_free;
    
28.                 std::thread *thread = nullptr;
    
29.                 void run();
    
30.                 void sleep();
    
31.         public:
    
32.                 void work(std::function<void ()> function);
    
33. };
    
34. 
    
35. class DistributeThread
    
36. {
    
37.         typedef std::pair<unsigned long long, unsigned int> queue_item;
    
38.         struct plan
    
39.         {
    
40.                 unsigned int delay;
    
41.                 std::function<void ()> function = nullptr;
    
42.                 BasicThread* thread;
    
43.         };
    
44.         public:
    
45.                 unsigned long long game_time = 0;
    
46.                 std::string name = "Distributor";
    
47.                 BasicThread * create(const char*);
    
48.                 BasicThread * get(const char*);
    
49.                 void join();
    
50.                 void repeat_work(const char* thread_name, unsigned int delay, std::function<void ()> function);
    
51.                 bool start();
    
52.                 void stop();
    
53.                 void work(const char* thread_name, std::function<void ()> function);
    
54.         protected:
    
55.                 unsigned int last_id = 0;
    
56.                 std::unordered_map<std::string, std::unique_lock<std::mutex>> locks;
    
57.                 std::map<unsigned int, plan> plans;
    
58.                 std::priority_queue<queue_item, std::vector<queue_item>, std::greater<queue_item>> queue;
    
59.                 bool running = true;
    
60.                 std::unordered_map<std::string, BasicThread*> threads;
    
61.                 std::thread *thread = nullptr;
    
62.                 void run();
    
63. };

复制代码