Не бойтесь велосипедов. Или еще один Grand Central Dispatch (GCD) на C++11

namespace dispatch{
    typedef std::function<void ()> function;
    struct queue {
        typedef long priority; // Наш приоритет. Пусть это будет целое число
        const queue::priority queue_priority; 

        static std::shared_ptr<queue> main_queue() ; // Об этом ниже

        virtual void async(function) const; // Собственно метод для добавления задачи в очередь

        queue(queue::priority priority) : queue_priority(priority) {};
    };
}

    void queue::async(dispatch::function task) const {
        thread_pool::shared_pool()->push_task_with_priority(task, this->queue_priority);
    };

    struct queue_impl{
        const queue::priority priority;
        std::queue<function> tasks;
        bool is_running;
        queue_impl(queue::priority priority): priority(priority){};
    };
    
    struct thread_pool{
        thread_pool();
        static std::shared_ptr<thread_pool>& shared_pool(); // thread_pool
        virtual ~thread_pool();
        
        bool stop;
        
        typedef std::shared_ptr<queue_impl> queue_ptr; 
        
        void push_task_with_priority(const function&, queue::priority);// Добавляем задачу в очередь с приоритетом
        bool get_free_queue(queue_ptr*) const;          // Ищем очередь, задачи из которой не исполняются прямо сейчас
        void start_task_in_queue(const queue_ptr&);  // Отмечаем очередь как исполняющуюся
        void stop_task_in_queue(const queue_ptr&);  // Снимаем отметку
        
        std::mutex mutex; // Мютекс для синхронизации пула
        std::map<queue::priority, queue_ptr> queues; // Здесь хранятся очереди по приоритетам
        
        std::mutex main_thread_mutex;
        std::queue<dispatch::function> main_queue;
        
        std::condition_variable condition;
        std::vector<std::thread> threads; // Массив реальных потоков, которые и будут выполнять задачи
        
        dispatch::function main_loop_need_update;
        void add_worker(); // Добавляем еще один поток
    };

   bool thread_pool::get_free_queue(queue_ptr* out_queue) const {
        //  проходим по всем очередям с приоритетом от максимального до минимального
       auto finded = std::find_if(queues.rbegin(), queues.rend(), [](const std::pair<queue::priority, queue_ptr>& iter){
                                         return ! iter.second->is_running; // и находим первую свободную очередь
                                     });
        
        bool is_free_queue_exist = (finded != queues.rend());
        if (is_free_queue_exist)
            *out_queue = finded->second;
        
        return  is_free_queue_exist;
    }

    void thread_pool::push_task_with_priority(const function& task, queue::priority priority){
        {
            std::unique_lock<std::mutex> lock(mutex); // Захватваем мютекс

            // Добавляем задачу в очередь. Если очереди нет - создаем ее
            auto queue = queues[priority];
            if (!queue){
                queue = std::make_shared<dispatch::queue_impl>(priority);
                queues[priority] = queue;
            }
            queue->tasks.push(task);

            // Если необходимо, то добавляем потоки
            unsigned max_number_of_threads = std::max<unsigned>(std::thread::hardware_concurrency(), 2);
            unsigned number_of_threads_required = round(log(queues.size()) + 1);
            while (threads.size() < std::min<unsigned>(max_number_of_threads, number_of_threads_required)){
                add_worker();
            }
        }
        condition.notify_one(); // Оповещаем поток, что мы добавили задачу в очередь
    }

    void thread_pool::stop_task_in_queue(const queue_ptr& queue){
        {
            std::unique_lock<std::mutex> lock(mutex);
           // Отмечаем задачу как выполненную. Если очередь пуста - убираем ее из списка очередей
            queue->is_running = false;
            if ( queue->tasks.size() ==0 ){
                queues.erase(queues.find(queue->queue_priority));
            }
        }
        condition.notify_one(); // Оповещаем поток, что одна из задач выполненна
    }

    void thread_pool::add_worker(){
        threads.push_back(std::thread([=]{
                              dispatch::function task;
                              thread_pool::queue_ptr queue;
                              while(true){
                                  {
                                      std::unique_lock<std::mutex> lock(mutex); // Пытаемся захватить мютекс
                                      
                                      while(!stop && !get_free_queue(&queue)) // Если нет свободных очередей
                                          condition.wait(lock);                   // То ждем оповещения
                                   
                                      if(stop) // Если пулл потоков был остановлен, то завершаемся
                                          return;

                                      task = queue->tasks.front(); // Забираем задачу из очереди
                                      queue->tasks.pop(); 

                                      start_task_in_queue(queue); // Отмечаем очередь как занятую
                                  }
                                  task(); // Исполняем задачу
                                  stop_task_in_queue(queue); // Отмечаем очередь как свободную
                              }
                          }));
    }

    struct main_queue : queue{
        virtual void async(dispatch::function task) const override;
        main_queue(): queue(0) {};
    };

    std::shared_ptr<queue> queue::main_queue(){
        return std::static_pointer_cast<dispatch::queue>(std::make_shared<dispatch::main_queue>());
    }

    void main_queue::async(dispatch::function task) const {
        auto pool = thread_pool::shared_pool();
        std::unique_lock<std::mutex> lock(pool->main_thread_mutex);
        pool->main_queue.push(task);
        if (pool->main_loop_need_update != nullptr)
            pool->main_loop_need_update();
    }

    void process_main_loop() {
        auto pool = thread_pool::shared_pool();
        std::unique_lock<std::mutex> lock(pool->main_thread_mutex);
        while (!pool->main_queue.empty()) {
            auto task = pool->main_queue.front();
            pool->main_queue.pop();
            task();
        }
    }

                          0
                          1
                     0
                0
                          2
                     1
                1
                          3
                     2
                2
                          4
                     3
                3
                          5
                     4
                4
           0
                     5
                5
           1
      0
 0
           2
      1
 1
           3
      2
 2
           4
      3
 3
           5
      4
 4
      5
 5

«Столбик» представляет собой очередь. Чем правее, тем более высокий приоритет у очереди. Линия — это коллбэки на «главный поток».