一个简单的线程池_threadpool(const threadpool &) = delete; threadpoo-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaofeilongyu/article/details/119985746

本文介绍了C++中实现一个简单的线程池，并提供了动态调整线程数量的功能。线程池通过任务队列管理和线程管理线程，支持不同优先级的任务执行。同时，代码展示了如何停止线程池，以及添加、移除任务。测试用例展示了如何向线程池添加任务并观察其工作流程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C++线程池

一个简单的线程池

1、核心组件设计

任务队列：需要考虑线程安全，一般使用std::queue+互斥锁或者std::deque+无锁队列实现
工作线程管理：初始化创建固定线程数量（std::thread数量默认机器硬件核心数），避免频繁的创建和销毁
同步机制：使用std:condition_variable通知线程有细腻任务或者终止信号

2、县成田安全与竞态条件

锁的颗粒度：任务入队和出队需要枷锁操作，尽量减少锁的持有时间。

条件变量：避免虚假唤醒（wait需要搭配条件查询和循环）。

std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [&]{ return !task.empty() || stop(); });

3、任务接口设计

泛型编程：使用std::function<void()>或者模板来接收任何可调用对象。

返回结果处理：使用std::future来异步处理返回结果。

template<typename F>
auto enqueue(F&& f) -> std::future<decltype(f())> {
    using retype = decltype(f());
    auto task = std::make_shared<std::packaged_task<retype()>>(std::forward<F>(f));
    std::future<retype> res = task->get_future();
    {
        std::lock_guard<std:mutex> lock(mtx);
        tasks.emplace([task](){ (*task)(); });
    }
    cv.notify_one();
    return res;
}

4、线程退出

终止标志：设置bool stop标志，通过cv.notify_all()唤醒所有线程

析构函数处理：确保所有线程都joi()，避免发生资源泄露

~ThreadPool() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        stop = true;
    }
    cv.notify_all();
    for (auto& : worker :workers) {
        worker.join();
    }
}

5、异常处理

任务异常传递：通过std::future的get()方法将异常抛回主线程

线程内部异常捕获异常：避免工作线程因未捕获异常而终止

void worker() {
    while(true) {
        Task task;
        {
            std::unique_lock<std::mutex> lock(mutex);
            cv.wait(lock, [this] () {return stop || !task.empty();});
            if (stop && tasks.empty()) return ;
            task = std::move(tasks.front());
            task.pop();
        }
        try{
            task();
        } catch (...) {
			// 记录相关异常日志
        }
    }
}

6、其他

性能优化：可以使用无所队列减少锁竞争的开销；允许空闲线程从其他线程任务i队列获取任务
资源管理：限制队列容量，防止无限制增长导致OOM；可根据负载动态增加或者减少线程数量
使用RAII管理锁和线程资源

7、完成代码

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

class ThreadPool {
public:
    explicit ThreadPool(size_t threads = std::thread::hardware_concurrency())
    : stop(false) {
        if(threads == 0) threads = 1;
        for(size_t i = 0; i < threads; ++i)
            workers.emplace_back([this] { worker(); });
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::invoke_result_t<F, Args...>> {
        using return_type = typename std::invoke_result_t<F, Args...>;
        
        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(queue_mutex);
            if(stop)
                throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks.emplace([task](){ (*task)(); });
        }
        condition.notify_one();
        return res;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for(std::thread &worker : workers)
            if(worker.joinable()) 
                worker.join();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;

    void worker() {
        while(true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                condition.wait(lock, [this]{
                    return stop || !tasks.empty();
                });
                
                if(stop && tasks.empty())
                    return;
                
                task = std::move(tasks.front());
                tasks.pop();
            }
            task();
        }
    }
};

/* 使用示例：
int main() {
    ThreadPool pool(4);
    std::vector<std::future<int>> results;

    for(int i = 0; i < 8; ++i) {
        results.emplace_back(pool.enqueue([i] {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            return i*i;
        }));
    }

    for(auto && result : results)
        std::cout << result.get() << ' ';
    std::cout << std::endl;
    
    return 0;
}
*/

8、其他

ThreadPool.h

#pragma once
#include <thread>
#include <mutex>
#include <memory>
#include <vector>
#include <list>
#include <iostream>
#include <condition_variable>
using namespace std;

class Task
{
public:
	virtual void DoWork()
	{
		cout << "task strat work!" << endl;
	}
	virtual ~Task()
	{
		cout << "one task distructed!" << endl;
	}
};

class ThreadPool
{
public:
	ThreadPool();
	~ThreadPool();
	//删除拷贝构造函数和赋值构造函数
	ThreadPool(const ThreadPool& tmp) = delete;
	ThreadPool& operator=(const ThreadPool& tmp) = delete;

	void Init();
	void Stop();
	void AddTask(Task* task);
	void removeAllTask();
private:
	void ThreaFunc();

private:
	list<shared_ptr<Task>> m_taskList;		//任务队列
	mutex m_mutexList;
	condition_variable m_cv;
	bool m_runFlag;
	vector<shared_ptr<thread>> m_threads;	//线程池
	int m_threadNum;						//线程数量
};

ThreadPool.cpp

#include "ThreadPool.h"

ThreadPool::ThreadPool():m_runFlag(false),m_threadNum(4)
{
}

ThreadPool::~ThreadPool()
{
	m_runFlag = false;
	removeAllTask();
}

void ThreadPool::Init()
{
	if (m_threadNum <= 0)
		m_threadNum = 4;

	m_runFlag = true;
	//初始化m_threadNum可线程
	for (int  i = 0; i < m_threadNum; i++)
	{
		shared_ptr<thread> tmpThread;
		tmpThread.reset(new thread(bind(&ThreadPool::ThreaFunc, this)));//绑定线程处理函数
		m_threads.push_back(tmpThread);
	}
}

void ThreadPool::Stop()
{
	m_runFlag = false;
	m_cv.notify_all();

	for (auto& it : m_threads)
	{
		if (it->joinable())
			it->join();
	}
}

void ThreadPool::AddTask(Task* task)
{
	shared_ptr<Task> tmpTask;
	tmpTask.reset(task);

	{
		lock_guard<mutex> guard(m_mutexList);
		m_taskList.push_back(tmpTask);
		cout << "add one task~" << endl;
	}
	m_cv.notify_one();
}

void ThreadPool::removeAllTask()
{
	lock_guard<mutex> guard(m_mutexList);
	for (auto it : m_taskList)
	{
		it.reset();
	}
	m_taskList.clear();
}

void ThreadPool::ThreaFunc()
{
	shared_ptr<Task> tmpTask;
	while (true)
	{
		{
			//lock_guard<mutex> guard(m_mutexList);
			//只能用unique_lock，不能用lock_gurad，因为条件变量等待时需要释放掉锁，唤醒时再加锁
			unique_lock<mutex> guard(m_mutexList);
			while (m_taskList.empty())
			{
				if (!m_runFlag)
					break;

				m_cv.wait(guard);
			}

			if (!m_runFlag)
				break;
			//任务队列获取一个任务
			tmpTask = m_taskList.front();
			m_taskList.pop_front();
		}

		if (tmpTask == nullptr)
			continue;

		tmpTask->DoWork();
		tmpTask.reset();
	}
	cout << "exit thead,threadId:" << this_thread::get_id() << endl;
}

测试函数

#include "ThreadPool.h"
int main()
{
	ThreadPool threadPool;
	threadPool.Init();

	Task* task = nullptr;
	for (size_t i = 0; i < 10; i++)
	{
		task = new Task();
		threadPool.AddTask(task);
	}
	this_thread::sleep_for(chrono::seconds(5));
	threadPool.Stop();
	system("PAUSE");
	return 0;
}

消息通知方：

获取mutex锁, 通常使用lock_guard
修改共享变量（即使是原子变量，也需要再互斥对象内进行，确保正确修改发布到等待的线程）
在 condition_variable 上执行 notify_one/notify_all 通知条件变量（该操作不需要锁）

消息等待方：

获取mutex锁, 通常使用unique_lock
执行 wait，wait_for或wait_until（该操作会自动释放锁并阻塞）
接收到条件变量通知、超时或者发生虚假唤醒时，线程被唤醒，并自动获取锁。唤醒的线程负责检查共享变量，如果是虚假唤醒，则应继续等待

[关于条件变量]
https://blog.youkuaiyun.com/c_base_jin/article/details/89741247

改进版

可动态调整线程池中线程数量

#pragma once
#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_
#include <thread>
#include <mutex>
#include <vector>
#include <list>
#include <future>
#include <condition_variable>
#include <atomic>
#include <iostream>
#include <map>

using Task = std::function<void()>;
enum TaskLevel
{
	high, middle, low
};

class TaskList
{
public:
	int ChangTaskLevel();
private:
	std::map<TaskLevel, std::list<std::shared_ptr<std::thread>>> task_list_;
	
};

class ThreadPool
{
public:
	
	ThreadPool();
	~ThreadPool();
	//删除拷贝构造函数和赋值构造函数
	ThreadPool(const ThreadPool& tmp) = delete;
	ThreadPool& operator=(const ThreadPool& tmp) = delete;

	void Init(const int min_thread_num, const int max_thread_num);
	void SetThreadNum(const int thread_num);
	
	template<typename F, typename... Args>
	//decltype(auto) AddTask(F&& func, Args&&... args);
	auto AddTask(F&& func, Args&&... args)->std::future<decltype(func(args...))>;

private:
	void Stop();
	void ThreaFunc();
	void RemoveAllTask();
	void ThreadManager();

private:
	std::list<std::shared_ptr<Task>> list_task_;		//任务队列
	std::mutex list_mutex_;
	std::condition_variable cv_;
	std::atomic<bool> run_flag_;
	std::vector<std::shared_ptr<std::thread>> thread_pool_;	//线程池
	std::thread manager_thread_;							//管理线程
	std::atomic<int> busy_thread_num_;						//忙碌线程数量
	int current_thread_num_;								//当前线程数量
	const int change_thread_num_;							//变动线程数量(每次增加或减少线程数量)
	int min_thread_num_;									//最小线程数量
	int max_thread_num_;									//最大线程数量
	std::atomic<int> wait_exit_thread_num_;					//等待销毁线程数量
};

template<typename F, typename... Args>
auto ThreadPool::AddTask(F&& func, Args&&... args)->std::future<decltype(func(args...))>
{
	// 把函数入口及参数,打包(绑定)
	using RetType = decltype(func(args...));
	auto task = std::make_shared<std::packaged_task<RetType()>>(std::bind(std::forward<F>(func), std::forward<Args>(args)...));
	std::future<RetType> future_result = task->get_future();
	// 添加任务到队列
	{
		std::lock_guard<std::mutex> guard(list_mutex_);
		list_task_.push_back(std::make_shared<Task>([task]() {(*task)(); }));
	}
	
	cv_.notify_one();
	return future_result;
}
#endif

#include "Thread_Pool.h"

using namespace std;

ThreadPool::ThreadPool():run_flag_(false),change_thread_num_(10){}

ThreadPool::~ThreadPool()
{
	Stop();
	RemoveAllTask();
}

void ThreadPool::Init(const int min_thread_num, const int max_thread_num)
{
	current_thread_num_ = min_thread_num;
	min_thread_num_ = min_thread_num;
	max_thread_num_ = max_thread_num;
	wait_exit_thread_num_ = 0;
	busy_thread_num_.store(0);

	if (min_thread_num <= 0)
	{
		current_thread_num_ = 4;
		min_thread_num_ = 4;
	}

	if (max_thread_num < min_thread_num)
	{
		max_thread_num_ = min_thread_num * 2;
	}

	run_flag_.store(true);
	//初始化m_threadNum可线程
	for (int i = 0; i < current_thread_num_; i++)
	{
		std::shared_ptr<std::thread> tmpThread;
		tmpThread.reset(new std::thread(std::bind(&ThreadPool::ThreaFunc, this)));//绑定线程处理函数
		thread_pool_.push_back(tmpThread);
	}
	
	//初始化管理线程
	manager_thread_ = move(thread(std::bind(&ThreadPool::ThreadManager, this)));
}
mutex mutk;
void ThreadPool::Stop()
{
	run_flag_.store(false);
	cv_.notify_all();
	
	if (manager_thread_.joinable())
	{
		manager_thread_.join();
		cout << "管理线程已推出" << endl;
	}
	
	for (auto& it : thread_pool_)
	{
		if (it->joinable())
			it->join();
	}
}

void ThreadPool::RemoveAllTask()
{
	std::lock_guard<std::mutex> guard(list_mutex_);
	for (auto it : list_task_)
	{
		it.reset();
	}
	list_task_.clear();
	return;
}

void ThreadPool::ThreaFunc()
{
	std::shared_ptr<Task> tmpTask;
	while (true)
	{
		{
			std::unique_lock<std::mutex> guard(list_mutex_);
			while (list_task_.empty())
			{
				if (!run_flag_.load())
					break;
				if (wait_exit_thread_num_ > 0)
				{
					wait_exit_thread_num_--;
					std::cout << "----,busy_thread_num_：" << busy_thread_num_ << "   wait----:" << wait_exit_thread_num_ << std::endl << std::endl;
					return;
				}

				cv_.wait(guard);
			}

			if (!run_flag_.load())
				break;
			//任务队列获取一个任务
			tmpTask = list_task_.front();
			list_task_.pop_front();
			busy_thread_num_++;
			cout << "busy_thread_num_++++++++:" << busy_thread_num_ << endl;
		}

		if (tmpTask == nullptr)
			continue;
		//执行list_task任务
		(*tmpTask.get())();
		
		std::unique_lock<std::mutex> guard(list_mutex_);
		cout << "this_thread_id:" << this_thread::get_id() << endl;
		tmpTask.reset();
		busy_thread_num_--;
		cout << "busy_thread_num_----:" << busy_thread_num_ << endl;
	}
	return;
}

void ThreadPool::ThreadManager()
{
	while (run_flag_.load())
	{
		//每隔5秒检测一次
		std::this_thread::sleep_for(std::chrono::seconds(5));
		std::lock_guard<std::mutex> guard(list_mutex_);
		std::cout << "adjust，busy_thread_num_：" << busy_thread_num_ << std::endl << std::endl;
		//增加线程数
		if (list_task_.size() > change_thread_num_ && current_thread_num_ < max_thread_num_)
		{
			int add_thread_num;
			if (current_thread_num_ + change_thread_num_ < max_thread_num_)
			{
				add_thread_num = change_thread_num_;
				current_thread_num_ += change_thread_num_;
			}
			else
			{
				add_thread_num = max_thread_num_ - current_thread_num_;
				current_thread_num_ = max_thread_num_;
			}
			
			for (int i = 0; i < add_thread_num; i++)
			{
				std::shared_ptr<std::thread> tmpThread;
				tmpThread.reset(new std::thread(std::bind(&ThreadPool::ThreaFunc, this)));
				thread_pool_.push_back(tmpThread);
			}
			std::cout << "current_thread_num_+++：" << current_thread_num_ << " task_num：" << list_task_.size() << std::endl << std::endl;
			continue;
		}
		//减少线程数
		if (busy_thread_num_ * 2 < current_thread_num_ && current_thread_num_ > min_thread_num_)
		{
			std::cout << "current_thread_num_---：" << current_thread_num_ << " busy_thread_num_：" << busy_thread_num_ << std::endl << std::endl;
			wait_exit_thread_num_.store(change_thread_num_);
			current_thread_num_ = current_thread_num_ - wait_exit_thread_num_;
			cv_.notify_all();
		}

		for (auto& it : thread_pool_)
		{
			if (it->joinable())
				it->join();
		}
	}
}

测试程序

#include <iostream>
#include "Thread_Pool.h"
#include <vector>
#include <functional>
using namespace std;

mutex mk;
void fun(int i, int j)
{
	lock_guard<mutex> guard(mk);
	std::cout << i << "-**********-" << j << std::endl;
	cout << "this_thread_id:" << this_thread::get_id() << endl;
	std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
	ThreadPool threadPool;
	threadPool.Init(4, 30);
	for (int i = 0; i < 60; i++)
	{
		threadPool.AddTask(fun, 123456, 78900);
	}

	std::this_thread::sleep_for(std::chrono::seconds(10));
	
	system("PAUSE");
	return 0;
}

改进版，增加任务优先级

#pragma once
#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_
#include <thread>
#include <mutex>
#include <vector>
#include <list>
#include <future>
#include <condition_variable>
#include <atomic>
#include <iostream>

using Task = std::function<void()>;
enum TaskLevel
{
	HIGHT, MIDDLE, LOW, DEFAULT
};

class ThreadPool
{
public:
	
	ThreadPool();
	~ThreadPool();
	//删除拷贝构造函数和赋值构造函数
	ThreadPool(const ThreadPool& tmp) = delete;
	ThreadPool& operator=(const ThreadPool& tmp) = delete;

	void Init(const int min_thread_num, const int max_thread_num);
	void SetThreadNum(const int thread_num);
	
	template<typename F, typename... Args>
	//decltype(auto) AddTask(F&& func, Args&&... args);
	auto AddTask(TaskLevel task_level, F&& func, Args&&... args)->std::future<decltype(func(args...))>;
	
private:
	void Stop();
	void ThreaFunc();
	void RemoveAllTask();
	void ThreadManager();
	TaskLevel GetTaskLevel();
	int GetTaskNum();

private:
	std::list<std::shared_ptr<Task>> hight_task_list_;		//高优先级任务队列
	std::list<std::shared_ptr<Task>> middle_task_list_;		//中优先级任务队列
	std::list<std::shared_ptr<Task>> low_task_list_;		//低优先级任务队列
	int hight_task_num_;									//高优先级任务队列执行计数器
	int middle_task_num_;									//中优先级任务队列执行计数器
	int low_task_num_;										//低优先级任务队列执行计数器
	std::mutex list_mutex_;									//任务队列锁
	std::condition_variable cv_;							//条件变量
	std::atomic<bool> run_flag_;							//线程池运行标志
	std::vector<std::shared_ptr<std::thread>> thread_pool_;	//线程池
	std::thread manager_thread_;							//管理线程
	std::atomic<int> busy_thread_num_;						//忙碌线程数量
	int current_thread_num_;								//当前线程数量
	const int change_thread_num_;							//变动线程数量(每次增加或减少线程数量)
	int min_thread_num_;									//最小线程数量
	int max_thread_num_;									//最大线程数量
	std::atomic<int> wait_exit_thread_num_;					//等待销毁线程数量
};

template<typename F, typename... Args>
auto ThreadPool::AddTask(TaskLevel task_level, F&& func, Args&&... args)->std::future<decltype(func(args...))>
{
	// 把函数入口及参数,打包(绑定)
	using RetType = decltype(func(args...));
	auto task = std::make_shared<std::packaged_task<RetType()>>(std::bind(std::forward<F>(func), std::forward<Args>(args)...));
	std::future<RetType> future_result = task->get_future();
	// 添加任务到队列
	{
		std::lock_guard<std::mutex> guard(list_mutex_);
		switch (task_level)
		{
		case HIGHT:
			hight_task_list_.push_back(std::make_shared<Task>([task]() {(*task)(); }));
			break;

		case MIDDLE:
			middle_task_list_.push_back(std::make_shared<Task>([task]() {(*task)(); }));
			break;

		case LOW:
			low_task_list_.push_back(std::make_shared<Task>([task]() {(*task)(); }));
			break;

		default:
			middle_task_list_.push_back(std::make_shared<Task>([task]() {(*task)(); }));
			break;
		}
	}
	
	cv_.notify_one();
	return future_result;
}
#endif

#include "Thread_Pool.h"

using namespace std;

ThreadPool::ThreadPool():run_flag_(false),change_thread_num_(10){}

ThreadPool::~ThreadPool()
{
	Stop();
	RemoveAllTask();
}

void ThreadPool::Init(const int min_thread_num, const int max_thread_num)
{
	hight_task_num_ = 0;
	middle_task_num_ = 0;
	low_task_num_ = 0;
	current_thread_num_ = min_thread_num;
	min_thread_num_ = min_thread_num;
	max_thread_num_ = max_thread_num;
	wait_exit_thread_num_ = 0;
	busy_thread_num_.store(0);
	

	if (min_thread_num <= 0)
	{
		current_thread_num_ = 4;
		min_thread_num_ = 4;
	}

	if (max_thread_num < min_thread_num)
	{
		max_thread_num_ = min_thread_num * 2;
	}

	run_flag_.store(true);
	//初始化m_threadNum可线程
	for (int i = 0; i < current_thread_num_; i++)
	{
		std::shared_ptr<std::thread> tmpThread;
		tmpThread.reset(new std::thread(std::bind(&ThreadPool::ThreaFunc, this)));//绑定线程处理函数
		thread_pool_.push_back(tmpThread);
	}
	
	//初始化管理线程
	manager_thread_ = move(thread(std::bind(&ThreadPool::ThreadManager, this)));
}
mutex mutk;
void ThreadPool::Stop()
{
	run_flag_.store(false);
	cv_.notify_all();
	
	if (manager_thread_.joinable())
	{
		manager_thread_.join();
		cout << "管理线程已推出！" << endl;
	}
	
	for (auto& it : thread_pool_)
	{
		if (it->joinable())
			it->join();
	}
}

void ThreadPool::RemoveAllTask()
{
	std::lock_guard<std::mutex> guard(list_mutex_);
	for (auto it : hight_task_list_)
	{
		it.reset();
	}
	hight_task_list_.clear();

	for (auto it : middle_task_list_)
	{
		it.reset();
	}
	middle_task_list_.clear();

	for (auto it : low_task_list_)
	{
		it.reset();
	}
	low_task_list_.clear();

	return;
}

void ThreadPool::ThreaFunc()
{
	std::shared_ptr<Task> tmpTask;
	while (true)
	{
		{
			std::unique_lock<std::mutex> guard(list_mutex_);
			while (hight_task_list_.empty() && middle_task_list_.empty() && low_task_list_.empty())
			{
				if (!run_flag_.load())
					break;
				if (wait_exit_thread_num_ > 0)
				{
					wait_exit_thread_num_--;
					std::cout << "----busy_thread_num_：" << busy_thread_num_ << "   wait----:" << wait_exit_thread_num_ << std::endl << std::endl;
					return;
				}

				cv_.wait(guard);
			}

			if (!run_flag_.load())
				break;
			//任务队列获取一个任务
			TaskLevel task_level = GetTaskLevel();
			switch (task_level)
			{
			case HIGHT:
				tmpTask = hight_task_list_.front();
				hight_task_list_.pop_front();
				cout << "HIGHT thread_task run @@@!" << endl;
				break;

			case MIDDLE:
				tmpTask = middle_task_list_.front();
				middle_task_list_.pop_front();
				cout << "middle thread_task run ***!" << endl;
				break;

			case LOW:
				tmpTask = low_task_list_.front();
				low_task_list_.pop_front();
				cout << "LOW thread_task run ###!" << endl;
				break;

			default:
				tmpTask = middle_task_list_.front();
				middle_task_list_.pop_front();
				break;
			}

			busy_thread_num_++;
			cout << "busy_thread_num_++++++++:" << busy_thread_num_ << endl;
		}

		if (tmpTask == nullptr)
			continue;
		//执行list_task任务
		Task func = *tmpTask.get();
		func();
		
		std::unique_lock<std::mutex> guard(list_mutex_);
		cout << "this_thread_id:" << this_thread::get_id() << endl;
		tmpTask.reset();
		busy_thread_num_--;
		cout << "busy_thread_num_----:" << busy_thread_num_ << endl;
	}
	return;
}

void ThreadPool::ThreadManager()
{
	while (run_flag_.load())
	{
		//每隔5秒检测一次
		std::this_thread::sleep_for(std::chrono::seconds(1));
		std::lock_guard<std::mutex> guard(list_mutex_);
		std::cout << "adjust，busy_thread_num_：" << busy_thread_num_ << std::endl << std::endl;
		//当任务队列中待处理任务数量超过变动线程数量的2倍时，需要增加线程池中线程数
		if (GetTaskNum() > change_thread_num_ * 2 && current_thread_num_ < max_thread_num_)
		{
			int add_thread_num;
			if (current_thread_num_ + change_thread_num_ < max_thread_num_)
			{
				add_thread_num = change_thread_num_;
				current_thread_num_ += change_thread_num_;
			}
			else
			{
				add_thread_num = max_thread_num_ - current_thread_num_;
				current_thread_num_ = max_thread_num_;
			}
			
			for (int i = 0; i < add_thread_num; i++)
			{
				std::shared_ptr<std::thread> tmpThread;
				tmpThread.reset(new std::thread(std::bind(&ThreadPool::ThreaFunc, this)));
				thread_pool_.push_back(tmpThread);
			}
			std::cout << "current_thread_num_+++：" << current_thread_num_ << " task_num：" << GetTaskNum() << std::endl << std::endl;
			continue;
		}
		//当2倍的忙碌线程数小于当前线程数时，需要减少线程池中的线程数
		if (busy_thread_num_ * 2 < current_thread_num_ && current_thread_num_ > min_thread_num_)
		{
			std::cout << "current_thread_num_---：" << current_thread_num_ << " busy_thread_num_：" << busy_thread_num_ << std::endl << std::endl;
			int reduce_thread_num;
			if (current_thread_num_ - change_thread_num_ >= min_thread_num_)
				reduce_thread_num = change_thread_num_;
			else
				reduce_thread_num = current_thread_num_ - min_thread_num_;

			wait_exit_thread_num_.store(reduce_thread_num);
			current_thread_num_ = current_thread_num_ - wait_exit_thread_num_;
			cv_.notify_all();
		}
	}
	return;
}

TaskLevel ThreadPool::GetTaskLevel()
{
	while (true)
	{
		if (!hight_task_list_.empty() && hight_task_num_ < 10)
		{
			hight_task_num_++;
			return HIGHT;
		}
		else if (!middle_task_list_.empty() && middle_task_num_ < 10)
		{
			middle_task_num_++;
			return MIDDLE;
		}
		else if (!low_task_list_.empty() && low_task_num_ < 10)
		{
			low_task_num_++;
			return LOW;
		}
		else
		{
			if (hight_task_num_ >= 10)
				hight_task_num_ = 0;
			if (middle_task_num_ >= 10)
				middle_task_num_ = 0;
			if (low_task_num_ >= 10)
				low_task_num_ = 0;
		}
	}

	return DEFAULT;
}

int ThreadPool::GetTaskNum()
{
	return hight_task_list_.size() + middle_task_list_.size() + low_task_list_.size();
}