C++线程池看这篇就够了，支持不同优先级，支持带返回值

//header 
#pragma once
#include <functional>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <future>

enum class TaskPriority:int
{
  kTP_Highest,
  kTP_Normal
};


class TaskEvent final
{
public:
  TaskEvent(std::function<void()>f, TaskPriority p=TaskPriority::kTP_Highest):
  m_event(f),
  m_priority(p)
  {}

  const TaskPriority priority()const noexcept
{
    return m_priority;
  }

  void operator()()
{
    m_event();
  }

private:
    std::function<void()> m_event{nullptr};
    TaskPriority m_priority;
};

struct Compare {
  bool operator()(const std::shared_ptr <TaskEvent>& left, const std::shared_ptr <TaskEvent>& right) 
{   
    return left->priority() > right->priority(); 
  }
};

class ThreadPool
{
public:
  ThreadPool(int thread_num=std::thread::hardware_concurrency(), int max_thread_num= 4* std::thread::hardware_concurrency());
  ~ThreadPool();

  void AddTask(std::function<void()> t);
  void AddTask(std::shared_ptr<TaskEvent> te);

  template<typename F, typename... Args>
  auto AddHasResultTask(F&& f, Args&&... args) -> std::shared_future<decltype(f(args...))>//shared_futrue for saved into vector or queue
{
    using returnType = decltype(f(args...));
    auto task = std::make_shared<std::packaged_task<returnType()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    std::shared_future<returnType> result = task->get_future().share();

    auto  t = std::make_shared<TaskEvent>([task]() {          (*task)();       });
    AddTask(t);
    return result;
  }

private:
  static void threadWorkFunction(void* p);

private:
  int m_current_thread_num{0};
  int m_max_thread_num{0};
  std::atomic_bool m_thread_pool_runing{true};

  //about threads
  std::vector<std::thread> m_threads;
  //about threads end

  //about tasks
  std::priority_queue< std::shared_ptr<TaskEvent>,std::vector<std::shared_ptr<TaskEvent>>,Compare>m_tasks_queue;//priority queue
  std::mutex m_tasks_mtx;
  std::condition_variable m_tasks_cv;
  //about tasks end
};


//source file
#include "ThreadPool.h"

ThreadPool::ThreadPool(int thread_num, int max_thread_num):
m_current_thread_num(thread_num),
m_max_thread_num(max_thread_num)
{
  for (int i =0; i< m_current_thread_num; i++)
  {
    m_threads.emplace_back(&ThreadPool::threadWorkFunction, this);
  }
}

ThreadPool::~ThreadPool()
{
  m_thread_pool_runing.store(false);
  m_tasks_cv.notify_all();
  for (auto& t : m_threads)
  {
    if (t.joinable())
    {

      t.join();
    }
  }
}

void ThreadPool::AddTask(std::function<void()> t)
{
  AddTask(std::make_shared<TaskEvent>(t));
}

void ThreadPool::AddTask(std::shared_ptr<TaskEvent> te)
{
  
  if (!m_thread_pool_runing)
  {
    return;//do not add new task
  }

  std::unique_lock<std::mutex> lk(m_tasks_mtx);
  m_tasks_queue.push(te);
  int size = m_tasks_queue.size();
  lk.unlock();

  if (size> m_current_thread_num && size<m_max_thread_num)
  {
    m_threads.emplace_back(&ThreadPool::threadWorkFunction, this);
  }
  m_tasks_cv.notify_all();
}

void ThreadPool::threadWorkFunction(void* p)
{
  if (!p)
  {
    return;
  }

  auto pool = static_cast<ThreadPool*>(p);
  if (!pool)
  {
    return;
  }

  //stop tasks and tasks queue is empty, will exit thread
  while (pool->m_thread_pool_runing.load()
    || pool->m_tasks_queue.size()>0)
  {
    std::unique_lock<std::mutex> lk(pool->m_tasks_mtx);
    pool->m_tasks_cv.wait(lk, [p_lambda = pool ]()->bool{
      return !p_lambda->m_tasks_queue.empty()||!p_lambda->m_thread_pool_runing.load();
    });

    if (!pool->m_tasks_queue.empty())
    {
      auto task = pool->m_tasks_queue.top();
      pool->m_tasks_queue.pop();

      (*task)();
    }
  }
}



//test file

int a = 100;
std::mutex g_mtx;

void use_thread_pool()
{
  std::shared_ptr<ThreadPool> pool=std::make_shared<ThreadPool>();

  for (int i = 0; i<10; i++)
  {
    pool->AddTask([]() {
      std::unique_lock<std::mutex> lk(g_mtx);
      a += 100;
      std::cout<<"thread id="<< std::this_thread::get_id()<<" a="<<a<<"\n";
      //printf("thread id=%s, a=%d \n",ss.str(),a);
      });
  }
  std::this_thread::sleep_for(std::chrono::seconds(5));
  pool.reset();
}

const int data_size = 3;
const int calculate_time= 10;
void use_thread_pool_with_result()
{
  float* result_data = (float*)malloc(data_size* sizeof(float));
  memset(result_data,0, data_size * sizeof(float));

  std::vector<std::shared_future<float*>> sf_vec;
  sf_vec.reserve(calculate_time);
  std::shared_ptr<ThreadPool> pool = std::make_shared<ThreadPool>();

  for (int i = 0; i < calculate_time; i++)
  {
    auto sf = pool->AddHasResultTask([]() ->float*{
      float* t = (float*)malloc(data_size * sizeof(float));
      t[0]=1;
      t[1]=2;
      t[2]=3;
      return t;
      });
    sf_vec.push_back(sf);
  }

  for (auto sf: sf_vec)
  {
    auto t = sf.get();
    if (!t)
    {
      continue;
    }

    for (int i =0;i<data_size;i++)
    {
      result_data[i]+=t[i];
    }
    free(t);
  }
  for (int i = 0; i < data_size; i++)
  {
    std::cout<<result_data[i] <<"\t";
  }
  std::cout<<"\n";
  free(result_data);
}