timer

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
#include <list>

pthread_t test_timer_tid;

static long curr_time;
static long min_time = 0;

typedef struct
{
    int start_time; //should be time_t for precision
    int duration; //should be time_t for precision
    void *sock;
}Timer;

std::list<Timer> timers;

static void handler(int s)
{
    //should lock here

    if(timers.empty())
    {
        return;
    }

    std::list<Timer>::iterator it = timers.begin();

    curr_time = time(0);
    min_time = it->duration - (curr_time - it->start_time);
    printf("min_time: %d curr_time: %d\n", (int)min_time, (int)curr_time);

    if(min_time > 0)
    {
        alarm(min_time);
    }

    //should unlock here

    signal(SIGALRM, handler);
}

static void check_timers()
{
    //should lock here

    std::list<Timer>::iterator it;

    curr_time = time(0);
    int i(0), time_left(0);
    for(it = timers.begin(); it != timers.end(); )
    {
        time_left = it->duration - (curr_time - it->start_time);
        printf("----- %d time_left: %d\n", ++i, time_left);
        if(time_left <= 0)
        {
            //it->sock callback, 处理该定时器事件
            timers.erase(it++);
        }
        else
        {
            it++;
        }
    }

    //should unlock here

    handler(0);
}

//timer loop, only should be called in main thread
static void timer()
{
    static int count = 1;
    handler(0);
    while(1)
    {
        printf("pause()\n");
        pause();
        printf("count: %d\n", count++);

        //check timer list/queue
        check_timers();
    }
    return;
}

//add a timer
void add_timer(Timer &t)
{
    //should lock here

    std::list<Timer>::iterator it;

    curr_time = time(0);
    for(it = timers.begin(); it != timers.end(); it++)
    {
        if((it->duration - (curr_time - it->start_time)) > t.duration)
        {
            timers.insert(it, t);
            break;
        }
    }
    if(it == timers.end())
    {
        timers.push_back(t);
    }

    //should unlock here
    handler(0);
}

void *test_timer(void *arg)
{
    while(1)
    {
        sleep(2);
        Timer t;
        t.start_time = time(0);
        t.duration = 10;
        add_timer(t);

        if(min_time == 2)
        {
            break;
        }
    }
    return (void*)0;
}

int main()
{
    int err;

    //thread for test
    err = pthread_create(&test_timer_tid, NULL, test_timer, NULL);
    if(err != 0)
    {
        printf("create test_timer thread error: %s/n",strerror(err));
        return 1;
    }

    timer();

    pthread_join(test_timer_tid, 0);

    return 0;
}