C++ 线程池

 

#ifndef H_THREAD_POOL_H
#define H_THREAD_POOL_H

#include <vector>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>
#include <stdexcept>

namespace std 
{
#define  THREADPOOL_MAX_NUM 16

	class ThreadPool 
	{
	public:
		ThreadPool(size_t);
		void addThread(size_t threads);
		template<class F, class... Args>
		auto enqueue(F&& f, Args&&... args)
			-> std::future<typename std::result_of<F(Args...)>::type>;
		~ThreadPool();
	private:
		// need to keep track of threads so we can join them
		std::vector< std::thread > m_workers;
		// the task queue
		std::queue< std::function<void()> > m_tasks;

		// synchronization
		std::mutex m_queue_mutex;
		std::condition_variable m_condition;
		bool m_b_stop;
	};

	// the constructor just launches some amount of workers
	inline ThreadPool::ThreadPool(size_t threads)
		:   m_b_stop(false)
	{
		addThread(threads);
	}
	void ThreadPool::addThread(size_t threads)
	{
		size_t pools = m_workers.size();
		for(;pools < THREADPOOL_MAX_NUM && threads > 0;--threads)
		{
			m_workers.emplace_back(
				[this]
				{
					for(;;)
					{
						std::function<void()> task;

						{
							std::unique_lock<std::mutex> lock(this->m_queue_mutex);
							this->m_condition.wait(lock,
								[this]{ return this->m_b_stop || !this->m_tasks.empty(); });
							if(this->m_b_stop && this->m_tasks.empty())
								return;
							task = std::move(this->m_tasks.front());
							this->m_tasks.pop();
						}

						task();
					}
				}
			);
		}
	}
	// add new work item to the pool
	template<class F, class... Args>
	auto ThreadPool::enqueue(F&& f, Args&&... args)
		-> std::future<typename std::result_of<F(Args...)>::type>
	{
		using return_type = typename std::result_of<F(Args...)>::type;

		auto task = std::make_shared< std::packaged_task<return_type()> >(
				std::bind(std::forward<F>(f), std::forward<Args>(args)...)
			);

		std::future<return_type> res = task->get_future();
		{
			std::unique_lock<std::mutex> lock(m_queue_mutex);

			// don't allow enqueueing after stopping the pool
			if(m_b_stop)
				throw std::runtime_error("enqueue on stopped ThreadPool");

			m_tasks.emplace([task](){ (*task)(); });
		}
		m_condition.notify_one();
		return res;
	}

	// the destructor joins all threads
	inline ThreadPool::~ThreadPool()
	{
		{
			std::unique_lock<std::mutex> lock(m_queue_mutex);
			m_b_stop = true;
		}
		m_condition.notify_all();
		for(std::thread &worker: m_workers)
			worker.join();
	}
}


#endif