Ошибка сегментации — boost::asio::detail::epoll_reactor::run()

Вы смешиваете io_service (!?) с io_context, используете boost::thread вместо std::thread, используете полноценный мьютекс для синхронизации с логическим значением (сделать его атомарным?), который является избыточным, поскольку таймер знает все, что он нужно знать. И при этом reset() и stop() вызывают Unопределённое поведение, потому что экземпляры steady_timer не являются потокобезопасными.

Вы присоединяетесь и отсоединяетесь от темы без всякой причины (здесь никогда не будет причин не присоединиться к ней). В общем, вы в основном реализуете очень дорогую версию

void on_timeout(Duration d, Callback cb) {
    std::thread{[d, cb] {
        std::this_thread::sleep_for(d);
        cb();
    }}.detach();
}

Пожалуй, единственная дополнительная функция — отложить его, позвонив reset(), пока он еще ждет. Подумайте о том, чтобы вообще не беспокоиться о теме:

struct AsyncExecutor {
    using Timer = asio::steady_timer;

    AsyncExecutor(Duration delay_ms, Callback callback) : delay_ms_(delay_ms), callback_(callback) {}

    ~AsyncExecutor() {
        trace("~dtor()");
        auto f = timer_.async_wait(asio::use_future);
        do_stop();
        f.wait(); // ensure the timer is done
    }

    void start() { trace("start()"); do_start(false); }
    void reset() { trace("reset()"); do_start(true);  }
    void stop()  { trace("stop()");  do_stop();       }

  private:
    static constexpr Timer::time_point STOPPED = Timer::time_point::min();

    asio::steady_timer timer_{make_strand(asio::system_executor{}), STOPPED};
    Duration           delay_ms_;
    Callback           callback_;

    void do_start(bool require_running) {
        dispatch(timer_.get_executor(), [this, require_running] {
            if (require_running == (timer_.expiry() != STOPPED)) {
                auto num_canceled = timer_.expires_after(delay_ms_);
                trace("  [setting delay, canceled " + std::to_string(num_canceled) + "]");
                timer_.async_wait(std::bind(&AsyncExecutor::timer_ran, this, _1));
            }
        });
    }

    std::future<size_t> do_stop() {
        return dispatch(timer_.get_executor(),
                        asio::use_future([this] { return timer_.expires_at(STOPPED); }));
    }

    void timer_ran(boost::system::error_code ec) {
        trace("  [timer_ran: " + ec.message() + "]");
        if (ec != asio::error::operation_aborted) {
            timer_.expires_at(STOPPED);
            if (callback_)
                callback_();
        }
    }
};

Обратите внимание, что все операции, кроме построения/разрушения, являются потокобезопасными.

Демо-программа:

Прямой эфир на Колиру

#include <boost/asio.hpp>
#include <fmt/core.h>
namespace asio = boost::asio;

using Callback = std::function<void()>;
using Duration = asio::steady_timer::duration;
using namespace std::placeholders;
using namespace std::chrono_literals;

namespace { // logging
    constexpr auto now   = std::chrono::steady_clock::now;
    auto           start = now();

    void trace(std::string const& msg) { fmt::print("at {:4}ms {}\n", (now() - start) / 1ms, msg); }
} // namespace

struct AsyncExecutor {
    using Timer = asio::steady_timer;

    AsyncExecutor(Duration delay_ms, Callback callback) : delay_ms_(delay_ms), callback_(callback) {}

    ~AsyncExecutor() {
        trace("~dtor()");
        auto f = timer_.async_wait(asio::use_future);
        do_stop();
        f.wait(); // ensure the timer is done
    }

    void start() { trace("start()"); do_start(false); }
    void reset() { trace("reset()"); do_start(true);  }
    void stop()  { trace("stop()");  do_stop();       }

  private:
    static constexpr Timer::time_point STOPPED = Timer::time_point::min();

    asio::steady_timer timer_{make_strand(asio::system_executor{}), STOPPED};
    Duration           delay_ms_;
    Callback           callback_;

    void do_start(bool require_running) {
        dispatch(timer_.get_executor(), [this, require_running] {
            if (require_running == (timer_.expiry() != STOPPED)) {
                auto num_canceled = timer_.expires_after(delay_ms_);
                trace("  [setting delay, canceled " + std::to_string(num_canceled) + "]");
                timer_.async_wait(std::bind(&AsyncExecutor::timer_ran, this, _1));
            }
        });
    }

    std::future<size_t> do_stop() {
        return dispatch(timer_.get_executor(),
                        asio::use_future([this] { return timer_.expires_at(STOPPED); }));
    }

    void timer_ran(boost::system::error_code ec) {
        trace("  [timer_ran: " + ec.message() + "]");
        if (ec != asio::error::operation_aborted) {
            timer_.expires_at(STOPPED);
            if (callback_)
                callback_();
        }
    }
};

using std::this_thread::sleep_for;
int main() {
    {
        trace("--- Main started");
        AsyncExecutor job(1500ms, [] {trace("~~~RUNNING TIMED JOB~~~"); });

        sleep_for(500ms);
        job.reset(); // no effect, not pending
        job.start();

        sleep_for(200ms);
        job.start(); // no effect, already pending

        trace("--- Main keeping the job alive");
        for (auto i = 0; i < 5; ++i) {
            job.reset(); // restarts the wait of 1500ms
            sleep_for(1.0s);
        }
        trace("--- Main loop done");

        sleep_for(1.0s); // this allows job to run

        job.reset(); // no effect, not pending
        job.start();

        sleep_for(200ms);
    } // destructor cancels the job
    trace("--- Main exit");
}

Печать, например:

Проблема была в порядке выполнения в timer_ran(). Это правильная версия:

if (ec) {
    return;
}

io_.stop();

if (this->callback_)
    this->callback_();

{
    std::lock_guard<std::mutex> lock(mutex_);
    is_running = false;
}

// Detach the thread, as it is no longer needed. It will be cleaned up by the OS.
this->thread_.detach();