Coroutine_handle возобновляет вызов из потока против jthread ⇐ C++

[Anonymous]

Я реализовал свой собственный экспериментальный объект awaiter сопрограммы, чтобы понять причину ожидания.
Я вызываю сопрограмму, которая в моем примере равна foo. В методе await_suspend я вызвал поток, и этот поток выполняет задание, поэтому в конце задания он возобновляет ожидание.
Однако, даже если я управляю жизненным циклом шага с помощью unique_ptr и управлять соединением в деструктуре ожидания, handle.resume каким-то образом генерирует segfault.
И последнее, но не менее важное: когда я использую jthread вместо потока, он работает нормально.
Я мог бы не понять, чего здесь не хватает.
#include
#include
#include

struct ReturnObject {
struct promise_type {
ReturnObject get_return_object() {
auto handle = std::coroutine_handle::from_promise(*this);
return ReturnObject{handle};
}
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }

void unhandled_exception() {
}

// void return_void() noexcept {
// }

void return_value(int val) noexcept {
this->value = val;
}

std::suspend_always yield_value(int val) {
this->value = val;
return std::suspend_always{};
}

double get_value() const noexcept { return value; }
void set_value(double val) noexcept { value = val; }

private:
double value{3.14};
};

std::coroutine_handle h_;

ReturnObject(std::coroutine_handle h) : h_{h} {
}

operator std::coroutine_handle() { return h_; }

int get_value() const {
return h_.promise().get_value();
}

~ReturnObject() {
h_.destroy();
}
};

void do_work(std::coroutine_handle& h) {
std::cout

Подробнее здесь: https://stackoverflow.com/questions/790 ... vs-jthread