ToB企服应用市场:ToB评测及商务社交产业平台

标题: C++编程：实现一个跨平台安全的定时器Timer模块 [打印本页]

---

作者: 前进之路    时间: 2024-7-24 08:18
标题: C++编程：实现一个跨平台安全的定时器Timer模块
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企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4