线程池和多线程的区别
线程池是事先实例化指定数量的线程（works），作为一个线程队列用于处理任务队列（tasks）的工作；相比多线程的优势是：不需要频繁创建和销毁线程对象，减少线程切换带来的时间和性能的消耗。
#ifndef _THREADPOOL_H_
#define _THREADPOOL_H_
#include <condition_variable>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <queue>
#include <stdexcept>
#include <thread>
#include <vector>
#include <iostream>
class ThreadPool {
public:
ThreadPool(size_t);
template <class F, class... Args>
void push(F&& f, Args&&... args);
~ThreadPool();
private:
// need to keep track of threads so we can join them
std::vector<std::thread> workers;
// the task queue
std::queue<std::function<void()> > tasks;
// synchronization
std::mutex queue_mutex;
std::condition_variable condition;
bool stop;
};
// the constructor just launches some amount of workers
inline ThreadPool::ThreadPool(size_t threads) : stop(false) {
for (size_t i = 0; i < threads; ++i) {
workers.emplace_back([this]() {
for (;;) {
std::function<void()> task;
{
std::unique_lock<std::mutex> lock(this->queue_mutex);
this->condition.wait(lock, [this](){ return this->stop || !this->tasks.empty(); });
//stop一般指该线程已经join了
if (this->stop) return;
task = std::move(this->tasks.front());
this->tasks.pop();
}
task();
}
});
}
}
// add new work item to the pool
template <class F, class... Args>
void ThreadPool::push(F&& f, Args&&... args) {
//std::bind:
std::function<void()> task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
{
std::unique_lock<std::mutex> lock(queue_mutex);
// don't allow enqueueing after stopping the pool
if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
tasks.emplace(task);
}
condition.notify_one();
}
// the destructor joins all threads
inline ThreadPool::~ThreadPool() {
{
std::unique_lock<std::mutex> lock(queue_mutex);
stop = true;
}
condition.notify_all();
for (std::thread& worker : workers) worker.join();
}
#endif
