Task.cpp

浏览该文件的文档.

#include "thread/Task.h"
 
#include "common/Exception.h"
 
namespace eve {
namespace thread {
 
Task::Task(std::function<void()> fn) {
    if (!fn)
        throw eve::Exception("Task function is null");
    state_ = std::make_shared<State>(std::move(fn));
}
 
Task::Task(std::shared_ptr<State> state) : state_(std::move(state)) {}
 
Task::~Task() = default;
 
std::string Task::getStatus() const {
    std::lock_guard<std::mutex> lock(state_->mu);
    return state_->status;
}
 
bool Task::isDone() const {
    std::lock_guard<std::mutex> lock(state_->mu);
    return state_->status == "done" || state_->status == "failed";
}
 
bool Task::hasFailed() const {
    std::lock_guard<std::mutex> lock(state_->mu);
    return state_->status == "failed";
}
 
std::string Task::getError() const {
    std::lock_guard<std::mutex> lock(state_->mu);
    return state_->error;
}
 
void Task::wait() {
    auto state = state_;
    std::unique_lock<std::mutex> lock(state->mu);
    state->cv.wait(lock, [&state] { return state->status == "done" || state->status == "failed"; });
}
 
void Task::run() {
    run(state_);
}
 
void Task::run(const std::shared_ptr<State> &state) {
    {
        std::lock_guard<std::mutex> lock(state->mu);
        state->status = "running";
    }
 
    try {
        state->fn();
        std::lock_guard<std::mutex> lock(state->mu);
        state->status = "done";
    } catch (const eve::Exception &e) {
        std::lock_guard<std::mutex> lock(state->mu);
        state->status = "failed";
        state->error = e.what();
    } catch (const std::exception &e) {
        std::lock_guard<std::mutex> lock(state->mu);
        state->status = "failed";
        state->error = e.what();
    } catch (...) {
        std::lock_guard<std::mutex> lock(state->mu);
        state->status = "failed";
        state->error = "unknown exception";
    }
 
    state->cv.notify_all();
}
 
}  // namespace thread
}  // namespace eve