C++ 简易异步定时器实现

C++ 简易异步定时器实现

---

---

代码实现

1.引入库

#include <atomic>      // 提供多线程编程的原子操作。
#include <chrono>      // 提供处理时间间隔和时钟的工具。
#include <functional>  // 允许使用函数对象和回调。
#include <future>      // 提供异步编程的特性
#include <iostream>    // 包含输入/输出操作的功能（如 std::cout）。
#include <iterator>    // 定义不同容器的迭代器支持。
#include <mutex>       // 提供互斥原语（如互斥锁）以确保线程安全。
#include <ostream>     // 包含输出流类和函数。
#include <thread>      // 支持多线程，包括线程创建和操作。

2.定时器模块

class Timer {
  public:
    // 停止定时器并等待当前任务完成
    void stop() {
        std::lock_guard<std::mutex> lock(timer_mutex); // 锁定互斥量以确保线程安全
        is_running = false; // 设置定时器状态为不运行
        if (timer_future.valid()) { // 检查任务是否有效
            timer_future.wait(); // 等待任务完成
        }
    }

    // 启动定时器，延迟指定秒数后执行回调函数
    void start(int delay_in_seconds, std::function<void()> callback) {
        std::lock_guard<std::mutex> lock(timer_mutex); // 锁定互斥量以确保线程安全
        if (is_running) {
            stop(); // 如果定时器正在运行，先停止它
        }
        is_running = true; // 设置定时器状态为运行
        timer_future = std::async(
            std::launch::async, [this, delay_in_seconds, callback]() {
                for (int i = 0; i < delay_in_seconds; ++i) {
                    if (!is_running) // 如果定时器已停止，退出循环
                        return;
                    std::this_thread::sleep_for(std::chrono::seconds(1)); // 每秒等待
                }
                if (is_running) { // 如果定时器仍在运行，调用回调函数
                    callback();
                }
            });
    }

    // 构造函数，初始化定时器状态
    Timer() : is_running(false) {}

    // 析构函数，确保定时器在对象销毁时停止
    ~Timer() { stop(); }

    // 返回定时器是否正在运行
    bool running() const { return is_running; }

  private:
    std::atomic<bool> is_running; // 原子变量，表示定时器状态
    std::future<void> timer_future; // 存储异步任务的未来对象
    std::mutex timer_mutex; // 互斥量，用于保护定时器状态
};

3.测试

int main() {
    Timer timer;
    std::cout << "启动5s的定时器任务..." << std::endl;
    timer.start(
        5, []() { std::cout << "定时器结束，执行回调函数！" << std::endl; });
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "主线程等待中..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    return 0;
}

4.完整代码

#include <atomic>
#include <chrono>
#include <functional>
#include <future>
#include <iostream>
#include <iterator>
#include <mutex>
#include <ostream>
#include <thread>
/*
基于C++提供的future和asyn接口，编写的一个简单的异步定时器
*/
class Timer {
  public:
    void stop() {
        std::lock_guard<std::mutex> lock(timer_mutex);
        is_running = false;
        if (timer_future.valid()) {
            timer_future.wait();
        }
    }
    void start(int delay_in_seconds, std::function<void()> callback) {
        std::lock_guard<std::mutex> lock(timer_mutex);
        if (is_running) {
            stop();
        }
        is_running = true;
        timer_future = std::async(
            std::launch::async, [this, delay_in_seconds, callback]() {
                for (int i = 0; i < delay_in_seconds; ++i) {
                    if (!is_running)
                        return;
                    std::this_thread::sleep_for(std::chrono::seconds(1));
                }
                if (is_running) {
                    callback();
                }
            });
    }
    Timer() : is_running(false) {}
    ~Timer() { stop(); }
    bool running() const { return is_running; }

  private:
    std::atomic<bool> is_running;
    std::future<void> timer_future;
    std::mutex timer_mutex;
};

int main() {
    Timer timer;
    std::cout << "启动5s的定时器任务..." << std::endl;
    timer.start(
        5, []() { std::cout << "定时器结束，执行回调函数！" << std::endl; });
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "主线程等待中..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    return 0;
}

总结

这个代码实现了一个简单的异步定时器 Timer 类，利用 C++ 的 std::future 和 std::async 进行多线程处理。定时器的主要功能包括：

1. 启动定时器：通过 start 方法，可以设置一个延迟时间和一个回调函数。定时器在延迟结束后会自动执行这个回调。
2. 停止定时器：可以使用 stop 方法来停止定时器，并等待当前正在执行的任务完成。
3. 线程安全：使用 std::mutex 确保在多线程环境中安全地访问和修改定时器的状态。
4. 异步执行：定时器的延迟处理在一个独立线程中进行，主线程可以继续执行其他操作。

在 main 函数中，定时器启动了一个 5 秒的任务，同时模拟了主线程的等待。任务完成后，输出相关信息。