动手实现C++线程池

简易线程池用于优化高并发计算，ipp加速，多级流水线并发运算
避免频繁的创建线程且保持线程数量与核心数量一致使其更快加速计算

#include <list>
#include <vector>
#include <memory>
#include <thread>
#include <mutex>
#include <atomic>
#include <functional>
#include <condition_variable>


namespace utils {

	class ThreadPool
	{
	protected:
		std::list<std::function<void()>> m_tasks;
		std::vector<std::unique_ptr<std::thread>> m_threads;
		std::condition_variable m_condition;
		std::mutex m_mtx;
		std::condition_variable m_doneCondition;
		std::mutex m_doneMtx;
		bool m_stop;
		size_t m_maxTasks;
		size_t m_leftTasks;

	public:
		ThreadPool(int threadCount, size_t maxTask = 0)
		{
			m_maxTasks = maxTask;
			m_leftTasks = 0;
			m_stop = false;

			for (int i = 0; i < threadCount; ++i) {
				m_threads.emplace_back(new std::thread([&]() {
					std::function<void()> task;
					while (true) {
						{
							std::unique_lock<std::mutex> lock(m_mtx);
                            if (m_stop)
                                break;
							if (m_tasks.empty())
								m_condition.wait(lock);
							if (m_tasks.empty())
								continue;
							task = m_tasks.front();
							m_tasks.pop_front();
						}
						task();
						{
							std::unique_lock<std::mutex> doneLock(m_doneMtx);
							m_leftTasks -= 1;
							m_doneCondition.notify_all();
						}
					}
                }));
			}
		}

		~ThreadPool()
        {
            {
                std::unique_lock<std::mutex> lock(m_mtx);
                m_stop = true;
                m_condition.notify_all();
            }
			for (auto& thread : m_threads) {
				if (thread->joinable())
					thread->join();
			}
		}

		void schedule(const std::function<void()>& func)
		{
			{
				std::unique_lock<std::mutex> doneLock(m_doneMtx);
				if (m_maxTasks > 0 && m_leftTasks >= m_maxTasks)
					m_doneCondition.wait(doneLock);
                m_leftTasks += 1;
			}


			std::unique_lock<std::mutex> lock(m_mtx);
			m_tasks.emplace_back(func);
			m_condition.notify_one();
		}

		void wait()
		{
			while (true) {
				std::unique_lock<std::mutex> doneLock(m_doneMtx);
				if (m_leftTasks == 0)
					return;
				m_doneCondition.wait(doneLock);
				if (m_leftTasks == 0)
					return;
			}
		}

	};

}