如何在C++中实现一个正确的时间循环器详解

2023-07-14 01:01:03 76

前言

实际工程中可能会有这样一类普遍需求：在服务中，单独起一个线程，以一个固定的时间间隔，周期性地完成特定的任务。我们把这种问题抽象成一个时间循环器。

NaiveWay

classTimerCircle{
private:
std::atomic_boolrunning_{false};
uint64_tsleep_{0UL};
std::threadthread_;

public:
explicitTimerCircle(uint64_ts):sleep_{s}{}
~TimerCircle(){
if(thread_.joinable()){
terminate();
thread_.join();
}
}
TimerCircle(constTimerCircle&)=delete;
TimerCircle&operator=(constTimerCircle&)=delete;
TimerCircle(TimerCircle&&)=default;
TimerCircle&operator=(TimerCircle&&)=default;

public:
voidlaunch(){
thread_=std::move(std::thread(&TimerCircle::loop,this));
}
voidterminate(){
running_.store(false);
}
voidloop(){
running_.store(true);
while(running_.load()){
do_something();
std::this_thread::sleep_for(std::chrono::seconds(sleep_));
}
}

private:
voiddo_something()const=0;
};

实现简单平凡，一眼就能看出来没啥问题，于是也没啥好说的。

细节里的魔鬼

唯一的魔鬼藏在细节里。如果TimerCircle类型的对象发生析构，那么析构该对象的线程最多会被阻塞sleep_秒。如果周期很长，比如长达6小时，那这显然是不可接受。

为此，我们需要借助标准库的条件变量std::condition_variable的wait_for函数的帮助。首先看其函数签名

template
boolwait_for(std::unique_lock&lock,
conststd::chrono::duration&rel_time,
Predicatepred);

函数接受三个参数。lock是一个unique_lock，它必须为调用wait_for的线程所锁住；rel_time是一个时间段，表示超时时间；pred是一个谓词，它要么返回true要么返回false。

一旦调用，函数会阻塞当前线程，直到两种情况返回：

超时；此时函数返回pred()。
条件变量被通知，且谓词返回true；此时函数返回true。

于是我们可以实现一个Countdown类

#include
#include
#include

classCountdownfinal{
private:
boolrunning_=true;
mutablestd::mutexmutex_;
mutablestd::condition_variablecv_;

public:
Countdown()=default;
~Countdown()=default;
Countdown(constCountdown&)=delete;
Countdown&operator=(constCountdown&)=delete;
Countdown(Countdown&&)=delete;
Countdown&operator=(Countdown&&)=delete;

public:
voidterminate(){
{
std::lock_guardlock(mutex_);
running_=false;
}
cv_.notify_all();
}

template
boolwait_for(std::chrono::duration&&duration)const{
std::unique_locklock(mutex_);
boolterminated=cv_.wait_for(lock,duration,[&](){return!running_;});
return!terminated;
}
};

于是，TimerCircle就变成

classTimerCircle{
private:
uint64_tsleep_{0UL};
Countdowncv_;
std::threadthread_;

public:
explicitTimerCircle(uint64_ts):sleep_{s}{}
~TimerCircle(){
if(thread_.joinable()){
terminate();
thread_.join();
}
}
TimerCircle(constTimerCircle&)=delete;
TimerCircle&operator=(constTimerCircle&)=delete;
TimerCircle(TimerCircle&&)=default;
TimerCircle&operator=(TimerCircle&&)=default;

public:
voidlaunch(){
thread_=std::move(std::thread(&TimerCircle::loop,this));
}
voidterminate(){
cv_.terminate();
}
voidloop(){
while(cv_.wait_for(std::chrono::seconds(sleep_))){
do_something();
}
}

private:
voiddo_something()const=0;
};

简单，明了。

总结

到此这篇关于如何在C++中实现一个正确的时间循环器的文章就介绍到这了,更多相关C++实现时间循环器内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！

如何在C++中实现一个正确的时间循环器详解

热门推荐

随机推荐