线程池不适用于大量任务
Thread pools not working with large number of tasks
我正在尝试使用本机 C++ 创建线程池,并且我正在使用“C++ 并发实战”一书中的代码清单。我遇到的问题是,当我提交的工作项多于线程数时,并不是所有的工作项都完成了。在下面的简单示例中,我尝试提交 运行Me() 函数 200 次,但函数 运行 只有 8 次。
这似乎不应该发生,因为在代码中,work_queue 与工作线程是分开的。这是代码:
#include "iostream"
#include "ThreadPool.h"
void runMe()
{
cout << "testing" << endl;
}
int main(void)
{
thread_pool pool;
for (int i = 0; i < 200; i++)
{
std::function<void()> myFunction = [&] {runMe(); };
pool.submit(myFunction);
}
return 0;
}
ThreadPool.h class
#include <queue>
#include <future>
#include <list>
#include <functional>
#include <memory>
template<typename T>
class threadsafe_queue
{
private:
mutable std::mutex mut;
std::queue<T> data_queue;
std::condition_variable data_cond;
public:
threadsafe_queue() {}
void push(T new_value)
{
std::lock_guard<std::mutex> lk(mut);
data_queue.push(std::move(new_value));
data_cond.notify_one();
}
void wait_and_pop(T& value)
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this] {return !data_queue.empty(); });
value = std::move(data_queue.front());
data_queue.pop();
}
bool try_pop(T& value)
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty())
return false;
value = std::move(data_queue.front());
data_queue.pop();
return true;
}
bool empty() const
{
std::lock_guard<std::mutex> lk(mut);
return data_queue.empty();
}
int size()
{
return data_queue.size();
}
};
class join_threads
{
std::vector<std::thread>& threads;
public:
explicit join_threads(std::vector<std::thread>& threads_) : threads(threads_) {}
~join_threads()
{
for (unsigned long i = 0; i < threads.size(); i++)
{
if (threads[i].joinable())
{
threads[i].join();
}
}
}
};
class thread_pool
{
std::atomic_bool done;
threadsafe_queue<std::function<void()> > work_queue;
std::vector<std::thread> threads;
join_threads joiner;
void worker_thread()
{
while (!done)
{
std::function<void()> task;
if (work_queue.try_pop(task))
{
task();
numActiveThreads--;
}
else
{
std::this_thread::yield();
}
}
}
public:
int numActiveThreads;
thread_pool() : done(false), joiner(threads), numActiveThreads(0)
{
unsigned const thread_count = std::thread::hardware_concurrency();
try
{
for (unsigned i = 0; i < thread_count; i++)
{
threads.push_back(std::thread(&thread_pool::worker_thread, this));
}
}
catch (...)
{
done = true;
throw;
}
}
~thread_pool()
{
done = true;
}
template<typename FunctionType>
void submit(FunctionType f)
{
work_queue.push(std::function<void()>(f));
numActiveThreads++;
}
int size()
{
return work_queue.size();
}
bool isQueueEmpty()
{
return work_queue.empty();
}
};
知道如何正确使用 work_queue 吗?
当 pool
在 main
结束时被销毁时,您的析构函数设置 done
,使您的工作线程退出。
你应该让析构函数(或者可能 main
,如果你想让它可选)在设置标志之前等待队列耗尽。
我正在尝试使用本机 C++ 创建线程池,并且我正在使用“C++ 并发实战”一书中的代码清单。我遇到的问题是,当我提交的工作项多于线程数时,并不是所有的工作项都完成了。在下面的简单示例中,我尝试提交 运行Me() 函数 200 次,但函数 运行 只有 8 次。 这似乎不应该发生,因为在代码中,work_queue 与工作线程是分开的。这是代码:
#include "iostream"
#include "ThreadPool.h"
void runMe()
{
cout << "testing" << endl;
}
int main(void)
{
thread_pool pool;
for (int i = 0; i < 200; i++)
{
std::function<void()> myFunction = [&] {runMe(); };
pool.submit(myFunction);
}
return 0;
}
ThreadPool.h class
#include <queue>
#include <future>
#include <list>
#include <functional>
#include <memory>
template<typename T>
class threadsafe_queue
{
private:
mutable std::mutex mut;
std::queue<T> data_queue;
std::condition_variable data_cond;
public:
threadsafe_queue() {}
void push(T new_value)
{
std::lock_guard<std::mutex> lk(mut);
data_queue.push(std::move(new_value));
data_cond.notify_one();
}
void wait_and_pop(T& value)
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this] {return !data_queue.empty(); });
value = std::move(data_queue.front());
data_queue.pop();
}
bool try_pop(T& value)
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty())
return false;
value = std::move(data_queue.front());
data_queue.pop();
return true;
}
bool empty() const
{
std::lock_guard<std::mutex> lk(mut);
return data_queue.empty();
}
int size()
{
return data_queue.size();
}
};
class join_threads
{
std::vector<std::thread>& threads;
public:
explicit join_threads(std::vector<std::thread>& threads_) : threads(threads_) {}
~join_threads()
{
for (unsigned long i = 0; i < threads.size(); i++)
{
if (threads[i].joinable())
{
threads[i].join();
}
}
}
};
class thread_pool
{
std::atomic_bool done;
threadsafe_queue<std::function<void()> > work_queue;
std::vector<std::thread> threads;
join_threads joiner;
void worker_thread()
{
while (!done)
{
std::function<void()> task;
if (work_queue.try_pop(task))
{
task();
numActiveThreads--;
}
else
{
std::this_thread::yield();
}
}
}
public:
int numActiveThreads;
thread_pool() : done(false), joiner(threads), numActiveThreads(0)
{
unsigned const thread_count = std::thread::hardware_concurrency();
try
{
for (unsigned i = 0; i < thread_count; i++)
{
threads.push_back(std::thread(&thread_pool::worker_thread, this));
}
}
catch (...)
{
done = true;
throw;
}
}
~thread_pool()
{
done = true;
}
template<typename FunctionType>
void submit(FunctionType f)
{
work_queue.push(std::function<void()>(f));
numActiveThreads++;
}
int size()
{
return work_queue.size();
}
bool isQueueEmpty()
{
return work_queue.empty();
}
};
知道如何正确使用 work_queue 吗?
当 pool
在 main
结束时被销毁时,您的析构函数设置 done
,使您的工作线程退出。
你应该让析构函数(或者可能 main
,如果你想让它可选)在设置标志之前等待队列耗尽。