133 lines
2.7 KiB
C++
133 lines
2.7 KiB
C++
#include <iostream>
|
|
|
|
|
|
#include <thread>
|
|
#include <mutex>
|
|
#include <functional>
|
|
#include <queue>
|
|
#include <condition_variable>
|
|
#include <vector>
|
|
|
|
class thread_pool {
|
|
public:
|
|
thread_pool(std::size_t size) : stop(false), exit_on_empty(false) {
|
|
for (std::size_t i = 0; i < size; ++i) {
|
|
workers.emplace_back([this] { spawn(); });
|
|
}
|
|
}
|
|
|
|
virtual ~thread_pool() {
|
|
if (!stop) join();
|
|
}
|
|
|
|
// template<class F, class... Args>
|
|
// void post(F&& f, Args&&... args) {
|
|
void post(std::function<void()> f) {
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
tasks.push(f);
|
|
}
|
|
|
|
condition.notify_one();
|
|
}
|
|
|
|
void join() {
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
stop = true;
|
|
}
|
|
|
|
condition.notify_all();
|
|
|
|
for (std::size_t i = 0; i < workers.size(); ++i) {
|
|
workers[i].join();
|
|
}
|
|
}
|
|
|
|
void finish_tasks() {
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
exit_on_empty = true;
|
|
}
|
|
|
|
while (!tasks.empty()) {
|
|
condition.notify_all();
|
|
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
condition_empty.wait(lock, [this]() {
|
|
return (tasks.empty());
|
|
});
|
|
}
|
|
|
|
// BLEJU, BLEJU
|
|
// while (!tasks.empty()) condition.notify_all();
|
|
bool op = true;
|
|
}
|
|
|
|
private:
|
|
void spawn() {
|
|
std::function<void()> task;
|
|
|
|
while (!stop && (!exit_on_empty || !tasks.empty())) {
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
condition.wait(lock, [this]() {
|
|
return (!tasks.empty()) || (tasks.empty() && stop);
|
|
});
|
|
|
|
if (!tasks.empty()) {
|
|
task = std::move(tasks.front());
|
|
tasks.pop();
|
|
task();
|
|
}
|
|
}
|
|
if (exit_on_empty) {
|
|
condition_empty.notify_one();
|
|
}
|
|
}
|
|
|
|
public:
|
|
std::vector<std::thread> workers;
|
|
std::queue<std::function<void()>> tasks;
|
|
|
|
std::mutex mutex;
|
|
std::condition_variable condition;
|
|
std::condition_variable condition_empty;
|
|
bool stop;
|
|
bool exit_on_empty;
|
|
};
|
|
|
|
// template<class F, class... Args>
|
|
// inline void dispatch(thread_pool& pool, F&& f, Args&&... args) {
|
|
inline void dispatch(thread_pool& pool, std::function<void()> f) {
|
|
pool.post(f);
|
|
}
|
|
|
|
|
|
|
|
// int main() {
|
|
// int cnt = 0;
|
|
|
|
// thread_pool tp{std::thread::hardware_concurrency()};
|
|
// std::mutex mutex;
|
|
|
|
// std::cout << "start" << std::endl;
|
|
|
|
// for(int i=0; i<100; i++) {
|
|
// dispatch(tp, std::function<void()>
|
|
// ([i, &cnt, &mutex]() {
|
|
// std::cout << "test " << i << std::endl;
|
|
// {
|
|
// std::unique_lock<std::mutex> lock(mutex);
|
|
// cnt++;
|
|
// }
|
|
// }
|
|
// ));
|
|
// }
|
|
|
|
|
|
// std::cout << "end" << std::endl;
|
|
// tp.join();
|
|
// std::cout << "cnt:" << cnt << std::endl;
|
|
|
|
// }
|