Blog

// Win32 SetTimer처럼 콜백에 타이머 id만 넘겨주는 C 타이머 API (가상 시간으로 동작)
#pragma once
#include <vector>

typedef void (*TIMERPROC)(int id);

struct TimerSlot { int id, period, next; TIMERPROC fn; bool alive; };
inline std::vector<TimerSlot> g_timers;
inline int g_next_id = 1;
inline int g_now = 0;                            // 가상 시각(ms)

inline int set_timer(int period_ms, TIMERPROC fn)
{
    g_timers.push_back({g_next_id, period_ms, g_now + period_ms, fn, true});
    return g_next_id++;
}
inline void kill_timer(int id)
{
    for (auto& t : g_timers) if (t.id == id) t.alive = false;
}
inline void run_timers(int duration_ms)           // 이벤트 루프: 1ms씩 시간을 흘린다
{
    for (int end = g_now + duration_ms; g_now < end; ) {
        int now = ++g_now;
        for (std::size_t i = 0; i < g_timers.size(); ++i)
            if (g_timers[i].alive && g_timers[i].next == now) {
                g_timers[i].next += g_timers[i].period;
                g_timers[i].fn(g_timers[i].id);
            }
    }
}

#include <cstdio>
#include "ctimer.h"

void on_fast(int id) { std::printf("  fast (id=%d)\n", id); }
void on_slow(int id) { std::printf("  slow (id=%d)\n", id); }

int main()
{
    set_timer(100, on_fast);
    set_timer(250, on_slow);
    run_timers(500);
}

#include <cstdio>
#include <string>
#include "ctimer.h"

class Clock {
    std::string name_;
    static Clock* self_;                         // 콜백이 this를 찾기 위한 static 포인터 하나
    static void on_timer(int) { self_->tick(); }
    void tick() { std::printf("  [%s] tick\n", name_.c_str()); }
public:
    explicit Clock(std::string n) : name_(std::move(n)) {}
    void start(int ms) { self_ = this; set_timer(ms, &Clock::on_timer); }
};
Clock* Clock::self_ = nullptr;

int main()
{
    Clock seoul("Seoul"), paris("Paris");
    seoul.start(100);
    paris.start(150);
    run_timers(300);
}

#include <cstdio>
#include <map>
#include <string>
#include "ctimer.h"

class Clock {
    std::string name_;
    int id_ = 0;
    static inline std::map<int, Clock*> table_;  // 타이머 id -> 객체
    static void on_timer(int id)
    {
        if (auto it = table_.find(id); it != table_.end()) it->second->tick();
    }
    void tick() { std::printf("  [%s] tick\n", name_.c_str()); }
public:
    explicit Clock(std::string n) : name_(std::move(n)) {}
    void start(int ms)
    {
        id_ = set_timer(ms, &Clock::on_timer);
        table_[id_] = this;
    }
};

int main()
{
    Clock seoul("Seoul"), paris("Paris");
    seoul.start(100);
    paris.start(150);
    run_timers(300);
}

#include <cstdio>
#include <map>
#include <string>
#include "ctimer.h"

class Clock {
    std::string name_;
    int id_ = 0;
    static inline std::map<int, Clock*> table_;
    static void on_timer(int id) { if (auto it = table_.find(id); it != table_.end()) it->second->tick(); }
    void tick() { std::fprintf(stderr, "  [%s] tick\n", name_.c_str()); }
public:
    explicit Clock(std::string n) : name_(std::move(n)) {}
    void start(int ms) { id_ = set_timer(ms, &Clock::on_timer); table_[id_] = this; }
#ifdef FIXED
    ~Clock() { if (id_) { kill_timer(id_); table_.erase(id_); } }   // 등록 해제
#endif
};

int main()
{
    Clock seoul("Seoul");
    seoul.start(100);
    {
        auto* tmp = new Clock("Temporary-clock-name-long-enough");
        tmp->start(100);
        delete tmp;                              // 타이머는 그대로 남아 있다
    }
    run_timers(200);
}

#include <cstdio>
#include <functional>
#include <map>
#include "ctimer.h"

// 매핑 테이블을 한 곳에 모은 재사용 가능한 기반 클래스
class Timer {
    int id_ = 0;
    std::function<void()> fn_;
    static inline std::map<int, Timer*> table_;
    static void dispatch(int id) { if (auto it = table_.find(id); it != table_.end()) it->second->fn_(); }
public:
    Timer(int ms, std::function<void()> fn) : fn_(std::move(fn))
    {
        id_ = set_timer(ms, &Timer::dispatch);
        table_[id_] = this;
    }
    ~Timer() { kill_timer(id_); table_.erase(id_); }
    Timer(const Timer&) = delete;                // 테이블에 this가 들어 있으므로
    Timer& operator=(const Timer&) = delete;
};

class Clock {
    const char* name_;
    int sec_ = 0;
    Timer timer_;                                // 수명이 Clock과 같다
public:
    Clock(const char* n, int ms) : name_(n), timer_(ms, [this] { std::printf("  [%s] %d\n", name_, ++sec_); }) {}
};

class Blinker {
    bool on_ = false;
    Timer timer_{120, [this] { on_ = !on_; std::printf("  LED %s\n", on_ ? "on" : "off"); }};
};

int main()
{
    Clock c("Seoul", 100);
    Blinker b;
    {
        Clock tmp("Tmp", 70);
        run_timers(150);
    }                                            // tmp 소멸 -> 자동 해제
    std::puts("  -- Tmp destroyed --");
    run_timers(150);
}

#include <csignal>
#include <cstdio>
#include <ctime>
#include <unistd.h>
#include <atomic>

// POSIX timer_create는 sigev_value에 void*를 실어 주므로 매핑 테이블이 필요 없다
class Clock {
    const char* name_;
    std::atomic<int> ticks_{0};
    timer_t tid_{};
    static void on_timer(union sigval v) { static_cast<Clock*>(v.sival_ptr)->tick(); }
    void tick() { std::printf("  [%s] tick %d\n", name_, ++ticks_); }
public:
    Clock(const char* n, long ms) : name_(n)
    {
        sigevent sev{};
        sev.sigev_notify = SIGEV_THREAD;
        sev.sigev_notify_function = &Clock::on_timer;
        sev.sigev_value.sival_ptr = this;        // this를 직접 전달
        timer_create(CLOCK_MONOTONIC, &sev, &tid_);
        itimerspec its{{0, ms * 1'000'000}, {0, ms * 1'000'000}};
        timer_settime(tid_, 0, &its, nullptr);
    }
    ~Clock() { timer_delete(tid_); }
};

int main()
{
    Clock a("A", 100), b("B", 250);
    usleep(560'000);
}