Очередь на std::list

virtual result run() noexcept = 0;

#include <iostream>
#include <random>
#include <thread>
 
void payload()
{
    std::random_device dev;
    std::default_random_engine engine(dev());
    std::uniform_int_distribution<int> uniform_dist(0, 2);
    const int value = uniform_dist(engine);
    if(value == 0)
        throw std::exception();
}
 
void threadFunc()
{
    std::cout << "threadFunc: started"  << std::endl;
    payload();
    std::cout << "threadFunc: finished" << std::endl;
}
 
int main()
{
    std::cout << "main: started" << std::endl;
    std::thread foo(threadFunc);
    foo.join();
    std::cout << "main: finished" << std::endl;    
}

#include <iostream>
#include <random>
#include <thread>
 
void payload()
{
    std::random_device dev;
    std::default_random_engine engine(dev());
    std::uniform_int_distribution<int> uniform_dist(0, 2);
    const int value = uniform_dist(engine);
    if(value == 0)
        throw std::exception();
}
 
void threadFunc() noexcept
{
    try
    {
        std::cout << "threadFunc: started"  << std::endl;
        payload();
        std::cout << "threadFunc: finished" << std::endl;
    }
    catch(const std::exception& e)
    {
        std::cerr << "std::exception: " << e.what() << std::endl;
    }
    catch(...)
    {
        std::cerr << "exception: unknown" << std::endl;        
    }
}
 
int main()
{
    std::cout << "main: started" << std::endl;
    std::thread foo(threadFunc);
    foo.join();
    std::cout << "main: finished" << std::endl;    
}

    void run() noexcept
    {
        while(!this->queue.empty())
        {
            auto cur = this->pop();  // Не кидает исключения
            if(!cur)
                continue;
            
            const auto& name = cur->getName();  // Не кидает исключения
            
            try
            {
                std::cout << "(trace) task_pool.run(" << name << "): start\n";                
                const auto result = cur->run();
                if(!result)
                {
                    std::cout << "(trace) task_pool.run(" << name << "): "
                        "repeat after " << result.ms << " ms\n";                
 
                    queue.emplace(std::move(cur));
                }
                else
                    std::cout << "(trace) task_pool.run(" << name << "): done\n";                
                    
            }
            catch(const std::exception& e)
            {
                std::cerr << "task_pool.run(std::exception): from '" 
                    << name << "': " << e.what() << std::endl;
            }
            catch(...)
            {
                std::cerr << "task_pool.run(seh::exception): from '"
                    << name << "': unknown"  << std::endl;
            }
        }
    }

// Ответственность за исключения лежит на разработчике задачи
virtual result run() noexcept = 0;

// Ответственность за исключения лежит на разработчике пула задач
void run() noexcept

virtual result run() = 0;
virtual result handle(std::exception_ptr); noexcept

#include <thread>
#include <future>
#include <iostream>
#include <exception>
#include <type_traits>
 
enum result_code {STATUS_SUCCESS = 100, STATUS_OTHER};
 
struct base_task
{
    friend class pool;
    virtual void run() noexcept = 0;
 
protected:
    std::promise<std::underlying_type<result_code>::type> m_result;
};
 
struct task : base_task
{
 
    task(bool should_throw_exception) : m_should_throw_exception(should_throw_exception) {}
 
    void run() noexcept override
    {
        if (m_should_throw_exception) {
            // бросок исключения.. и не надо мне рассказывать, что должен быть именно throw (но если сильно надо и throw можно, 
            // просто тогда exception нужно будет получить через std::current_exception()
 
            // пытаемся мыслить нестандартно и понять, что эти механизмы в С++ добавлены не просто так
            std::exception_ptr ep = std::make_exception_ptr(std::runtime_error("Something wrong")); 
            m_result.set_exception(ep);
            return;
        }
 
        m_result.set_value(STATUS_SUCCESS);
    }
 
private:
    bool m_should_throw_exception;
};
 
struct pool
{
    std::future<std::underlying_type<result_code>::type> run(base_task* t) noexcept
    {
        auto result = t->m_result.get_future();
 
        std::thread th([t]
        {
            t->run();
        });
 
        th.detach();
 
        return result;
    }
};
 
void test(bool should_throw_exception)
{
    // это сторона, которая создает задачу... эта сторона вправе знать, что задача завершилась исключением
    pool p;
 
    try {
        auto pr = p.run(new task(should_throw_exception));
        auto result_from_thread = pr.get();
        std::cout << "result from thread: " << result_from_thread;
    }
    catch (std::runtime_error& e) {
        std::cout << "exception in task: " << e.what();
    }
 
    std::cout << std::endl;
}
 
int main()
{
    test(true);
    test(false);
}

#define TASK_THROW(task_exception) \
    std::exception_ptr ep = std::make_exception_ptr(task_exception); \
    m_result.set_exception(ep); \
    return;

TASK_THROW(std::runtime_error("Something wrong"));

server::log.info("text");

    void run() noexcept
    {
        while(!this->queue.empty())
        {
            ...
 
            try
            {
                ...
            }
            catch(const std::exception& e)
            {
                std::cerr << "task_pool.run(std::exception): from '" 
                    << name << "': " << e.what() << std::endl;
            }
            catch(...)
            {
                std::cerr << "task_pool.run(seh::exception): from '"
                    << name << "': unknown"  << std::endl;
            }
        }
    }

    void run() noexcept
    {
        while(!this->queue.empty())
        {
            ...
 
            try
            {
                ...
            }
            catch(const std::exception& e)
            {
                server::log.error("task_pool.run(std::exception): "
                    "from '%': %", name, e.what())
            }
            catch(...)
            {
                server::log.error("task_pool.run(exception): "
                    "from '%': unknown", name)
            }
        }
    }

// Класс конкретной задачи определяет не только метод run, но и метод handle
// С помощью handle задача описывает реакцию на возможные эксепшены
struct der: task
{
    void run() // Может бросить эксепшен
    {
        ... // Здесь только бизнес-логика
    }
 
    // А здесь - обработка исключений, которые вылетели из run
    virtual void handle(std::exception_ptr eptr) noexcept
    {
        try
        {
            assert(eptr);
            if (eptr)
                std::rethrow_exception(eptr);
        }
        catch(const std::exception& e)
        {
            server::log.error("std::exception: from 'der': %", e.what());
        }
        catch(...)
        {
            server::log.error("exception: from 'der': unknown");
        }
    }
};

void run() noexcept override
{
    if (m_should_throw_exception) {
        std::exception_ptr ep = std::make_exception_ptr(std::runtime_error("Something wrong"));   // UPPSSS
        m_result.set_exception(ep);
        return;
    }
 
    m_result.set_value(STATUS_SUCCESS);
}

void run() // Может бросить эксепшен
{
    if (пора_бросать_исключение) {handle(...)}
}