Commit 4656a714 authored by tqcq's avatar tqcq
Browse files

feat timer support Start/Stop in thread

parent 3da9625c

src/sled/timer/timer.cc

+31 −0
Original line number Diff line number Diff line 
#include "sled/timer/timer.h"

#include "sled/log/log.h"



namespace sled {

namespace {
@@ -9,6 +10,22 @@ MakeTimeoutId(TimerID timer_id, TimerGeneration generation) 
}

}// namespace



TimerThreadDeleter::TimerThreadDeleter(TaskQueueBase *owner) : owner_(owner) {}



void

TimerThreadDeleter::operator()(Timer *timer)

{

    if (!timer) { return; }

    if (owner_) {

        owner_->PostTask([timer]() {

            timer->Stop();

            delete timer;

        });

    } else {

        delete timer;

    }

}



Timer::Timer(TimerID id,

             const std::string &name,

             OnExpired on_expired,
@@ -53,6 +70,20 @@ Timer::Stop() 
    }

}



void

Timer::Start(TaskQueueBase *owner)

{

    SLED_ASSERT(owner != nullptr, "owner must not be nullptr");

    owner->BlockingCall([this]() { Start(); });

}



void

Timer::Stop(TaskQueueBase *owner)

{

    SLED_ASSERT(owner != nullptr, "owner must not be nullptr");

    owner->BlockingCall([this]() { Stop(); });

}



void

Timer::Trigger(TimerGeneration generation)

{

src/sled/timer/timer.h

+22 −13
Original line number Diff line number Diff line
@@ -13,6 +13,16 @@ namespace sled { 
typedef uint64_t TimerID;

typedef uint32_t TimerGeneration;



class Timer;



struct TimerThreadDeleter {

    TimerThreadDeleter(TaskQueueBase *owner);

    inline void operator()(Timer *timer);



private:

    TaskQueueBase *owner_;

};



class Timer {

public:

    using OnExpired                 = std::function<sled::optional<DurationMs>()>;
@@ -22,9 +32,12 @@ public: 
    void Start();

    void Stop();



    void Start(TaskQueueBase *owner);

    void Stop(TaskQueueBase *owner);



    void set_duration(DurationMs duration) { duration_ = duration; }



    const DurationMs &duration() const { return duration_; }

    const DurationMs duration() const { return duration_; }



    int expiration_count() const { return expiration_count_; }
@@ -46,7 +59,7 @@ private: 
    const UnregisterHandler unregister_handler_;

    std::unique_ptr<Timeout> timeout_;



    DurationMs duration_;

    std::atomic<DurationMs> duration_;



    TimerGeneration generation_ = TimerGeneration(0);

    bool is_running_            = false;
@@ -54,16 +67,12 @@ private: 
};



class TimerManager {

    using TimeoutCreator = std::function<std::unique_ptr<Timeout>(

        sled::TaskQueueBase::DelayPrecision)>;

    using TimeoutCreator = std::function<std::unique_ptr<Timeout>(sled::TaskQueueBase::DelayPrecision)>;



public:

    explicit TimerManager(TimeoutCreator timeout_creator)

        : timeout_creator_(timeout_creator)

    {}

    explicit TimerManager(TimeoutCreator timeout_creator) : timeout_creator_(timeout_creator) {}



    std::unique_ptr<Timer> CreateTimer(const std::string &name,

                                       Timer::OnExpired on_expired);

    std::unique_ptr<Timer> CreateTimer(const std::string &name, Timer::OnExpired on_expired);

    void HandleTimeout(TimeoutID timeout_id);



private: