软件看门狗的设计与实现

在软件开发中，特别是在嵌入式系统、实时系统或任何需要高可靠性和故障恢复能力的领域，看门狗（Watchdog）机制扮演着至关重要的角色。

看门狗通过监控系统的运行状态，并在系统出现故障或停止响应时采取相应措施（如重启系统或触发错误处理机制），来确保系统的稳定性和可靠性。

一 、看门狗的工作原理

看门狗机制通常基于一个定时器，该定时器被设置为在预设的时间间隔内重置（即“喂狗”）。如果系统在该时间间隔内未能重置定时器（即未能“喂狗”），则看门狗将认为系统已经停止响应，并触发一个错误处理函数，该函数可能执行重启系统、记录错误日志或发送警报等操作。

二、设计考虑

在设计软件看门狗时，需要考虑以下几个关键因素：

1. 超时时间：根据系统的特性和需求，合理设置看门狗的超时时间。超时时间太短可能导致误报，而超时时间太长则可能延迟故障的响应。

2. 错误处理机制：定义清晰的错误处理流程，包括在系统未响应时应该执行的操作。

3. 线程安全：由于看门狗可能会被多个线程或组件访问，因此需要确保其对共享资源的访问是线程安全的。

4. 灵活性：设计应支持多个看门狗实例，以便能够监控系统的不同部分。

三、实践示例

以下是一个在C++中实现的软件看门狗示例，包括看门狗类和看门狗管理类的实现，看门狗基类，该类包含基本的喂狗和超时处理逻辑。看门狗管理类，该类管理多个看门狗实例，并提供添加、删除和更新看门狗的方法。以及如何在主程序中使用它们。

#include <iostream>
#include <vector>
#include <functional>
#include <chrono>
#include <thread>
#include <mutex>
#include <condition_variable>

class WatchdogBase {
protected:
    std::chrono::steady_clock::time_point last_feed_time_;
    std::chrono::seconds timeout_;
    std::function<void()> on_timeout_action_;

    bool is_expired() const {
        return std::chrono::steady_clock::now() - last_feed_time_ > timeout_;
    }

public:
    WatchdogBase(std::chrono::seconds timeout, std::function<void()> on_timeout)
        : timeout_(timeout), last_feed_time_(std::chrono::steady_clock::now()), on_timeout_action_(on_timeout) {}

    virtual void feed() {
        last_feed_time_ = std::chrono::steady_clock::now();
    }

    virtual void check_and_handle_timeout() {
        if (is_expired() && on_timeout_action_) {
            on_timeout_action_();
        }
    }

    virtual ~WatchdogBase() {}
};

class WatchdogManager {
private:
    std::vector<std::unique_ptr<WatchdogBase>> watchdogs_;
    std::mutex mtx_;
    std::condition_variable cv_;
    bool running_ = true;

    void watchdog_thread() {
        while (running_) {
            std::unique_lock<std::mutex> lock(mtx_);
            cv_.wait_for(lock, std::chrono::seconds(1), [this] { return !watchdogs_.empty() || !running_; });

            if (!running_) break;

            for (auto& wd : watchdogs_) {
                wd->check_and_handle_timeout();
            }
        }
    }

public:
    WatchdogManager() {
        std::thread watchdog_thread_([this]() { watchdog_thread(); });
        watchdog_thread_.detach(); // 分离线程
    }

    ~WatchdogManager() {
        {
            std::lock_guard<std::mutex> lock(mtx_);
            running_ = false;
            cv_.notify_one();
        }

        // 等待看门狗线程退出（注意：这里实际上只是发送了停止信号，
        // 并没有等待线程真正结束，因为线程是分离的。如果需要等待，
        // 则需要使用joinable的线程，并在析构时join它。）
    }

    void add_watchdog(std::unique_ptr<WatchdogBase> watchdog) {
        std::lock_guard<std::mutex> lock(mtx_);
        watchdogs_.push_back(std::move(watchdog));
        cv_.notify_one(); // 通知看门狗线程可能有新的看门狗需要检查
    }

    // 其他管理函数，如删除看门狗（注意同步问题）
};

// 示例超时处理函数
void handle_timeout_for_motor() {
    std::cerr << "Motor watchdog timeout! Motor may be stuck." << std::endl;
    // 这里可以添加重启电机、发送警报等逻辑
}

// 示例看门狗实例
class MotorWatchdog : public WatchdogBase {
public:
    MotorWatchdog(std::chrono::seconds timeout, std::function<void()> on_timeout)
        : WatchdogBase(timeout, on_timeout) {}

    // 可以添加特定于电机的喂狗逻辑（如果有的话）
};

int main() {
    WatchdogManager wd_manager;

    // 添加一个电机看门狗实例
    wd_manager.add_watchdog(std::make_unique<MotorWatchdog>(5, handle_timeout_for_motor));

    // 模拟系统工作，定时喂狗
    for (int i = 0; i < 10; ++i) {
        std::cout << "Feeding watchdogs..." << std::endl;

        // 注意：这里我们无法直接访问wd_manager中的看门狗
    }
}