kTobeCheck, //! 未打卡

kChecked, //! 已打卡

kTimeout //! 打卡超时

kIdle, //!< 未启动

kRunning, //!< 运行中

kStoping, //!< 停止中

using SharedPtr = std::shared_ptr<LoopInfo>;

LoopInfo(event::Loop *l, const std::string &n) :

loop(l), name(n),

state(LoopState::kChecked)

{ }

event::Loop* loop;

std::string name;

LoopState state;

RECORD_SCOPE();

std::lock_guard<std::mutex> lg(_mutex_lock);

for (auto loop_info_sptr : _loop_info_vec) {

if (loop_info_sptr->loop->isRunning()) {

if (loop_info_sptr->state == LoopState::kChecked) {

loop_info_sptr->state = LoopState::kTobeCheck;

auto start_ts = std::chrono::steady_clock::now();

loop_info_sptr->loop->runInLoop(

[loop_info_sptr] {

if (loop_info_sptr->state == LoopState::kTimeout)

_loop_recover_cb(loop_info_sptr->name);

loop_info_sptr->state = LoopState::kChecked;

},

"LoopWdog"

);

auto time_cost = std::chrono::steady_clock::now() - start_ts;

if (time_cost > std::chrono::milliseconds(100)) {

LogWarn("loop \"%s\" runInLoop() cost > 100 ms, %lu us", loop_info_sptr->name.c_str(), time_cost.count() / 1000);

}

}

}

}

std::lock_guard<std::mutex> lg(_mutex_lock);

for (auto loop_info_sptr: _loop_info_vec) {

if (loop_info_sptr->state == LoopState::kTobeCheck) {

loop_info_sptr->state = LoopState::kTimeout;

_loop_die_cb(loop_info_sptr->name);

RECORD_EVENT();

}

}

LogDbg("LoopWDog started");

while (_wdog_state == WDogState::kRunning) {

SendLoopFunc();

for (int i = 0; i < 10 && _wdog_state == WDogState::kRunning; ++i)

std::this_thread::sleep_for(std::chrono::milliseconds(100));

if (_wdog_state == WDogState::kRunning)

CheckLoopTag();

}

LogDbg("LoopWDog stoped");

WDogState state = WDogState::kIdle;

if (_wdog_state.compare_exchange_strong(state, WDogState::kRunning)) {

_sp_thread = new std::thread(ThreadProc);

} else {

LogWarn("it's not idle, state:%d", state);

}

WDogState state = WDogState::kRunning;

if (_wdog_state.compare_exchange_strong(state, WDogState::kStoping)) {

_sp_thread->join();

CHECK_DELETE_RESET_OBJ(_sp_thread);

_loop_info_vec.clear();

_wdog_state = WDogState::kIdle;

} else {

LogWarn("it's not running. state:%d", state);

}

std::lock_guard<std::mutex> lg(_mutex_lock);

auto iter = std::find_if(_loop_info_vec.begin(), _loop_info_vec.end(),

[loop] (const LoopInfo::SharedPtr &loop_info_sptr) {

return loop_info_sptr->loop == loop;

}

);

if (iter == _loop_info_vec.end()) { //! 如果没有找到那么创建

_loop_info_vec.push_back(std::make_shared<LoopInfo>(loop, name));

}

std::lock_guard<std::mutex> lg(_mutex_lock);

auto iter = std::remove_if(_loop_info_vec.begin(), _loop_info_vec.end(),

[loop] (const LoopInfo::SharedPtr &loop_info_sptr) {

return loop_info_sptr->loop == loop;

}

);

if (iter != _loop_info_vec.end()) {

_loop_info_vec.erase(iter, _loop_info_vec.end());

}