C++编程：实现一个跨平台安全的定时器Timer模块

前进之路  金牌会员 | 2024-7-24 08:18:12 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 843|帖子 843|积分 2529

0. 概要

对于C++应用编程，定时器模块是一个至关重要的组件。为了确保系统的可靠性和功能安全，我们需要设计一个高效、稳固的定时器。
本文将实现一个跨平台安全的C++ SafeTimer 定时器模块，并提供完备的gtest单元测试。
完备代码见 gitee_safe_timer
雷同设计请参阅文章：C++编程： 线程池封装、使命异步执行以及使命延迟执行
1. 设计目标

目标是创建一个符合功能安全要求的定时器模块，具体包罗以下几点：

  • 线程安全：确保多线程环境下的安全性。
  • 高可靠性：在异常情况下能够安全地停止定时器。
  • 高可维护性：代码结构清楚，易于扩展和维护。
2. SafeTimer 类的实现

SafeTimer 类是我们实现的焦点，它提供了单次触发（SingleShot）和重复触发（Repeat）两种定时功能，同时还支持暂停（Pause）和恢复（Resume）。以下是 SafeTimer 类的完备实现。
2.1 头文件 safe_timer.h

  1. #ifndef SAFE_TIMER_H
  2. #define SAFE_TIMER_H
  4. #include <atomic>
  5. #include <chrono>
  6. #include <condition_variable>
  7. #include <functional>
  8. #include <memory>
  9. #include <mutex>
  10. #include <string>
  11. #include <thread>
  13. // 定义SafeTimer类，用于管理定时任务
  14. class SafeTimer {
  15. public:
  16.   // 构造函数，可以指定定时器的名称，默认为"SafeTimer"
  17.   explicit SafeTimer(const std::string& name = "SafeTimer") noexcept;
  19.   // 析构函数
  20.   virtual ~SafeTimer() noexcept;
  22.   // 禁止复制构造和赋值操作
  23.   SafeTimer(const SafeTimer&) = delete;
  24.   SafeTimer& operator=(const SafeTimer&) = delete;
  26.   // 返回定时器的名称
  27.   std::string GetName() const noexcept;
  29.   // 返回定时器是否处于循环模式
  30.   bool IsLoop() const noexcept;
  32.   // 设置一个一次性定时任务
  33.   template <typename Callable, typename... Arguments>
  34.   bool SingleShot(uint64_t interval_in_millis, Callable&& func, Arguments&&... args);
  36.   // 设置一个可重复的定时任务
  37.   template <typename Callable, typename... Arguments>
  38.   bool Repeat(uint64_t interval_in_millis, Callable&& func, Arguments&&... args);
  40.   // 设置一个可重复的定时任务，可以选择是否立即执行一次
  41.   template <typename Callable, typename... Arguments>
  42.   bool Repeat(uint64_t interval_in_millis, bool call_func_immediately, Callable&& func, Arguments&&... args);
  44.   // 取消当前的定时任务
  45.   void Cancel() noexcept;
  47.   // 暂停当前的定时任务
  48.   bool Pause() noexcept;
  50.   // 恢复已暂停的定时任务
  51.   void Resume() noexcept;
  53.   // 判断定时器是否处于空闲状态
  54.   bool IsTimerIdle() const noexcept;
  56. private:
  57.   // 启动定时任务的核心函数
  58.   bool Start(uint64_t interval_in_millis, std::function<void()> callback, bool loop, bool callback_immediately = false);
  60.   // 尝试使定时器过期，用于取消或暂停任务
  61.   void TryExpire() noexcept;
  63.   // 销毁线程资源
  64.   void DestroyThread() noexcept;
  66. private:
  67.   // 定时器的名称
  68.   std::string name_;
  70.   // 标记定时器是否为循环模式
  71.   bool is_loop_;
  73.   // 原子布尔类型，标记定时器是否已经过期
  74.   std::atomic_bool is_expired_;
  76.   // 原子布尔类型，标记是否尝试使定时器过期
  77.   std::atomic_bool try_to_expire_;
  79.   // 独占所有权的线程智能指针
  80.   std::unique_ptr<std::thread> thread_;
  82.   // 互斥锁，用于线程同步
  83.   std::mutex mutex_;
  85.   // 条件变量，用于线程间的通信
  86.   std::condition_variable condition_;
  88.   // 定时器启动时的时间点
  89.   std::chrono::time_point<std::chrono::steady_clock> start_time_;
  91.   // 定时器结束时的时间点
  92.   std::chrono::time_point<std::chrono::steady_clock> end_time_;
  94.   // 剩余任务时间（毫秒）
  95.   uint64_t task_remain_time_ms_;
  97.   // 回调函数，当定时器过期时调用
  98.   std::function<void()> callback_;
  99. };
  101. // 实现模板成员函数
  103. // 单次定时任务的实现
  104. template <typename Callable, typename... Arguments>
  105. bool SafeTimer::SingleShot(uint64_t interval_in_millis, Callable&& func, Arguments&&... args) {
  106.   // 创建一个绑定的函数对象，用于延迟执行
  107.   auto action = std::bind(std::forward<Callable>(func), std::forward<Arguments>(args)...);
  108.   // 调用私有的Start函数，设置一次性任务
  109.   return Start(interval_in_millis, action, false);
  110. }
  112. // 循环定时任务的实现
  113. template <typename Callable, typename... Arguments>
  114. bool SafeTimer::Repeat(uint64_t interval_in_millis, Callable&& func, Arguments&&... args) {
  115.   // 创建一个绑定的函数对象，用于延迟执行
  116.   auto action = std::bind(std::forward<Callable>(func), std::forward<Arguments>(args)...);
  117.   // 调用私有的Start函数，设置循环任务
  118.   return Start(interval_in_millis, action, true);
  119. }
  121. // 循环定时任务的实现，允许指定是否立即执行一次
  122. template <typename Callable, typename... Arguments>
  123. bool SafeTimer::Repeat(uint64_t interval_in_millis, bool call_func_immediately, Callable&& func, Arguments&&... args) {
  124.   // 创建一个绑定的函数对象，用于延迟执行
  125.   auto action = std::bind(std::forward<Callable>(func), std::forward<Arguments>(args)...);
  126.   // 调用私有的Start函数，设置循环任务，可选择立即执行
  127.   return Start(interval_in_millis, action, true, call_func_immediately);
  128. }
  130. #endif  // SAFE_TIMER_H
复制代码
源文件 safe_timer.cpp

  1. #include "safe_timer.h"
  2. #include <iostream>
  4. SafeTimer::SafeTimer(const std::string& name) noexcept
  5.     : name_(name), is_loop_(false), is_expired_(true), try_to_expire_(false), task_remain_time_ms_(0), callback_(nullptr) {}
  7. SafeTimer::~SafeTimer() noexcept {
  8.   TryExpire();
  9. }
  11. std::string SafeTimer::GetName() const noexcept {
  12.   return name_;
  13. }
  15. bool SafeTimer::IsLoop() const noexcept {
  16.   return is_loop_;
  17. }
  19. void SafeTimer::Cancel() noexcept {
  20.   if (is_expired_ || try_to_expire_ || !thread_) {
  21.     return;
  22.   }
  23.   TryExpire();
  24. }
  26. bool SafeTimer::Pause() noexcept {
  27.   if (is_expired_) {
  28.     return false;
  29.   }
  31.   auto now = std::chrono::steady_clock::now();
  32.   auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time_).count();
  33.   auto remaining = std::chrono::duration_cast<std::chrono::milliseconds>(end_time_ - now).count();
  35.   if (remaining <= 0) {
  36.     return false;
  37.   }
  39.   Cancel();
  40.   task_remain_time_ms_ = static_cast<uint64_t>(remaining);
  41.   return true;
  42. }
  44. void SafeTimer::Resume() noexcept {
  45.   if (task_remain_time_ms_ > 0 && callback_) {
  46.     Start(task_remain_time_ms_, callback_, false, false);
  47.     task_remain_time_ms_ = 0;
  48.   }
  49. }
  51. bool SafeTimer::IsTimerIdle() const noexcept {
  52.   return is_expired_ && !try_to_expire_;
  53. }
  55. bool SafeTimer::Start(uint64_t interval_in_millis, std::function<void()> callback, bool loop, bool callback_immediately) {
  56.   if (!is_expired_ || try_to_expire_) {
  57.     return false;
  58.   }
  60.   is_expired_ = false;
  61.   is_loop_ = loop;
  63.   DestroyThread();
  64.   thread_ = std::make_unique<std::thread>([this, interval_in_millis, callback, callback_immediately]() {
  65.     if (callback_immediately) {
  66.       callback();
  67.     }
  69.     while (!try_to_expire_) {
  70.       callback_ = callback;
  71.       start_time_ = std::chrono::steady_clock::now();
  72.       end_time_ = start_time_ + std::chrono::milliseconds(interval_in_millis);
  74.       std::unique_lock<std::mutex> lock(mutex_);
  75.       condition_.wait_until(lock, end_time_);
  77.       if (try_to_expire_) {
  78.         break;
  79.       }
  80.       callback();
  81.       if (!is_loop_) {
  82.         break;
  83.       }
  84.     }
  86.     is_expired_ = true;
  87.     try_to_expire_ = false;
  88.   });
  90.   return true;
  91. }
  93. void SafeTimer::TryExpire() noexcept {
  94.   try_to_expire_ = true;
  95.   DestroyThread();
  96.   try_to_expire_ = false;
  97. }
  99. void SafeTimer::DestroyThread() noexcept {
  100.   if (thread_) {
  101.     {
  102.       std::lock_guard<std::mutex> lock(mutex_);
  103.       condition_.notify_all();
  104.     }
  105.     if (thread_->joinable()) {
  106.       thread_->join();
  107.     }
  108.     thread_.reset();
  109.   }
  110. }
复制代码
3. 工作流程图

     这个流程图分别展示了 SingleShot 和 Repeat 的流程，同时包罗了暂停、恢复和取消操作。
4. 单元测试

为了验证 SafeTimer 的功能，我们编写了一组单元测试，覆盖了定时器的各种使用场景，包罗单次触发、重复触发、暂停、恢复和取消等功能。
  1. #include <gmock/gmock.h>
  2. #include <gtest/gtest.h>
  4. #include <chrono>
  5. #include <thread>
  7. #include "safe_timer.h"
  9. class CallbackMock {
  10. public:
  11.   MOCK_METHOD(void, CallbackMethod, ());
  12. };
  14. class SafeTimerTest : public testing::Test {
  15. protected:
  16.   CallbackMock callback_mock;
  18.   void SetUp() override {
  19.     // Do nothing now
  20.   }
  22.   void TearDown() override {
  23.     // Do nothing now
  24.   }
  25. };
  27. TEST_F(SafeTimerTest, SingleShot) {
  28.   SafeTimer timer("TestSingleShot");
  29.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(1);
  30.   int time_ms = 100;  // Delay time in milliseconds
  31.   bool ret = timer.SingleShot(time_ms, &CallbackMock::CallbackMethod, &callback_mock);
  32.   EXPECT_TRUE(ret);
  33.   // Sleep for an additional 100ms to ensure execution
  34.   std::this_thread::sleep_for(std::chrono::milliseconds(time_ms + 100));
  35. }
  37. TEST_F(SafeTimerTest, RepeatWithParamCallImmediately) {
  38.   SafeTimer timer("TestRepeatWithParamCallImmediately");
  39.   int repeat_count = 3;  // Number of times repeat should execute
  40.   int time_ms = 200;     // Delay time in milliseconds
  42.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(repeat_count);
  43.   // Execute once immediately
  44.   auto ret = timer.Repeat(time_ms, true, &CallbackMock::CallbackMethod, &callback_mock);
  45.   EXPECT_TRUE(ret);
  46.   // Sleep for an additional 100ms to ensure execution
  47.   std::this_thread::sleep_for(std::chrono::milliseconds((repeat_count - 1) * time_ms + 100));
  49.   // Cancel previous timer
  50.   timer.Cancel();
  51.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(repeat_count);
  52.   // Do not execute immediately
  53.   ret = timer.Repeat(time_ms, false, &CallbackMock::CallbackMethod, &callback_mock);
  54.   EXPECT_TRUE(ret);
  55.   // Sleep for an additional 100ms to ensure execution
  56.   std::this_thread::sleep_for(std::chrono::milliseconds(repeat_count * time_ms + 100));
  57. }
  59. TEST_F(SafeTimerTest, RepeatWithoutParamCallImmediately) {
  60.   SafeTimer timer("TestRepeatWithoutParamCallImmediately");
  61.   int repeat_count = 3;  // Number of times repeat should execute
  62.   int time_ms = 500;     // Delay time in milliseconds
  64.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(repeat_count);
  65.   auto ret = timer.Repeat(time_ms, &CallbackMock::CallbackMethod, &callback_mock);
  66.   EXPECT_TRUE(ret);
  67.   // Sleep for an additional 100ms to ensure execution
  68.   std::this_thread::sleep_for(std::chrono::milliseconds(repeat_count * time_ms + 100));
  69. }
  71. TEST_F(SafeTimerTest, Cancel) {
  72.   SafeTimer timer("Cancel");
  73.   int repeat_count = 3;  // Number of times repeat should execute
  74.   int time_ms = 500;  // Delay time in milliseconds
  76.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(repeat_count - 1);
  77.   // Execute once immediately
  78.   auto ret = timer.Repeat(time_ms, true, &CallbackMock::CallbackMethod, &callback_mock);
  79.   EXPECT_TRUE(ret);
  80.   // Sleep for 100ms less to ensure cancel is called in time
  81.   std::this_thread::sleep_for(std::chrono::milliseconds((repeat_count - 1) * time_ms - 100));
  82.   timer.Cancel();
  83. }
  85. // Test if cancelling immediately after timer creation causes any issues
  86. // Expected: Cancelling immediately after timer creation should directly return and perform no operation
  87. TEST_F(SafeTimerTest, CancelBeforeSingleShot) {
  88.   SafeTimer timer("TestCancelBeforeSingleShot");
  89.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(1);
  90.   timer.Cancel();
  91.   int time_ms = 100;  // Delay time in milliseconds
  92.   auto ret = timer.SingleShot(time_ms, &CallbackMock::CallbackMethod, &callback_mock);
  93.   EXPECT_TRUE(ret);
  94.   // Sleep for an additional 100ms to ensure execution
  95.   std::this_thread::sleep_for(std::chrono::milliseconds(time_ms + 100));
  96. }
  98. // Test if cancelling immediately after creating a SingleShot timer causes any issues
  99. // Expected: Properly cancel without issues
  100. TEST_F(SafeTimerTest, CancelImmediatelyAfterSingleShot) {
  101.   SafeTimer timer("TestCancelImmediatelyAfterSingleShot");
  102.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(0);
  103.   int time_ms = 100;  // Delay time in milliseconds
  104.   timer.SingleShot(time_ms, &CallbackMock::CallbackMethod, &callback_mock);
  105.   timer.Cancel();
  106.   // Sleep for an additional 100ms to ensure callback is not called
  107.   std::this_thread::sleep_for(std::chrono::milliseconds(time_ms + 100));
  108. }
  110. TEST_F(SafeTimerTest, CancelAfterSingleShot) {
  111.   SafeTimer timer("TestCancelAfterSingleShot");
  112.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(1);
  113.   int time_ms = 100;  // Delay time in milliseconds
  114.   auto ret = timer.SingleShot(time_ms, &CallbackMock::CallbackMethod, &callback_mock);
  115.   EXPECT_TRUE(ret);
  116.   // Sleep for an additional 100ms to ensure execution
  117.   std::this_thread::sleep_for(std::chrono::milliseconds(time_ms + 100));
  118.   timer.Cancel();
  119. }
  121. TEST_F(SafeTimerTest, Pause) {
  122.   SafeTimer timer("Pause");
  123.   int repeat_count = 2;  // Number of times repeat should execute
  124.   int time_ms = 500;  // Delay time in milliseconds
  126.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(repeat_count - 1);
  127.   // Execute once immediately
  128.   timer.Repeat(time_ms, true, &CallbackMock::CallbackMethod, &callback_mock);
  129.   // Sleep for 100ms less to ensure pause is called in time
  130.   std::this_thread::sleep_for(std::chrono::milliseconds((repeat_count - 1) * time_ms - 100));
  131.   auto ret = timer.Pause();
  132.   EXPECT_TRUE(ret);
  133. }
  135. TEST_F(SafeTimerTest, Resume) {
  136.   SafeTimer timer("Resume");
  137.   int repeat_count = 3;  // Number of times repeat should execute
  138.   int time_ms = 100;  // Delay time in milliseconds
  140.   EXPECT_CALL(callback_mock, CallbackMethod()).Times(repeat_count);
  141.   // Execute once immediately
  142.   timer.Repeat(time_ms, true, &CallbackMock::CallbackMethod, &callback_mock);
  143.   int time_advance_pause = 50;  // Time in milliseconds to pause in advance
  144.   // Sleep for time_advance_pause ms less to ensure pause is called in time
  145.   std::this_thread::sleep_for(std::chrono::milliseconds((repeat_count - 1) * time_ms - time_advance_pause));
  146.   timer.Pause();
  147.   timer.Resume();
  148.   // Sleep for an additional 100ms to ensure timer execution is completed
  149.   std::this_thread::sleep_for(std::chrono::milliseconds(time_advance_pause + 100));
  150. }
  152. int main(int argc, char** argv) {
  153.   testing::InitGoogleMock(&argc, argv);
  154.   return RUN_ALL_TESTS();
  155. }
复制代码
以上代码是使用Google Test和Google Mock进行单元测试，以下是几项要点：

  • 单次触发测试：

    • SingleShot测试了SafeTimer在设定的延时后只触发一次CallbackMethod。

  • 重复触发测试：

    • RepeatWithParamCallImmediately测试了计时器立即执行并重复触发回调的功能。
    • RepeatWithoutParamCallImmediately测试了计时器不立即执行，仅按照设定隔断重复触发回调的功能。

  • 取消计时器测试：

    • Cancel测试了在计时器执行过程中取消操作是否有效。
    • CancelBeforeSingleShot测试了在单次触发计时器创建后立即取消是否有效。
    • CancelImmediatelyAfterSingleShot测试了在单次触发计时器执行前立即取消的效果。
    • CancelAfterSingleShot测试了在单次触发计时器执行后再取消的效果。

  • 暂停与恢复计时器测试：

    • Pause测试了暂停计时器的功能。
    • Resume测试了暂停后恢复计时器的功能。

每个测试都使用EXPECT_CALL设置了预期的回调调用次数，并在恰当的延时时间后查抄回调是否按预期执行。
执行结果：
  1. $ ./safe_timer_test
  2. [==========] Running 9 tests from 1 test suite.
  3. [----------] Global test environment set-up.
  4. [----------] 9 tests from SafeTimerTest
  5. [ RUN      ] SafeTimerTest.SingleShot
  6. [       OK ] SafeTimerTest.SingleShot (200 ms)
  7. [ RUN      ] SafeTimerTest.RepeatWithParamCallImmediately
  8. [       OK ] SafeTimerTest.RepeatWithParamCallImmediately (1201 ms)
  9. [ RUN      ] SafeTimerTest.RepeatWithoutParamCallImmediately
  10. [       OK ] SafeTimerTest.RepeatWithoutParamCallImmediately (1600 ms)
  11. [ RUN      ] SafeTimerTest.Cancel
  12. [       OK ] SafeTimerTest.Cancel (900 ms)
  13. [ RUN      ] SafeTimerTest.CancelBeforeSingleShot
  14. [       OK ] SafeTimerTest.CancelBeforeSingleShot (200 ms)
  15. [ RUN      ] SafeTimerTest.CancelImmediatelyAfterSingleShot
  16. [       OK ] SafeTimerTest.CancelImmediatelyAfterSingleShot (201 ms)
  17. [ RUN      ] SafeTimerTest.CancelAfterSingleShot
  18. [       OK ] SafeTimerTest.CancelAfterSingleShot (200 ms)
  19. [ RUN      ] SafeTimerTest.Pause
  20. [       OK ] SafeTimerTest.Pause (400 ms)
  21. [ RUN      ] SafeTimerTest.Resume
  22. [       OK ] SafeTimerTest.Resume (300 ms)
  23. [----------] 9 tests from SafeTimerTest (5208 ms total)
  25. [----------] Global test environment tear-down
  26. [==========] 9 tests from 1 test suite ran. (5208 ms total)
  27. [  PASSED  ] 9 tests.
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

正序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

前进之路

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表