定时器类

timerhandler.hpp:


#ifndef _TIMER_H
#define _TIMER_H
#include <iostream>
#include <vector>
#include <time.h>
 
using namespace std;

class EventHandler{
private:
	int self_id;
public:
	static int id;
	int start_time;
	int execute_second;
public:
	EventHandler(int _second);
	virtual ~EventHandler();
	virtual void handler();
	bool operator ==(const EventHandler &eh2);
	int get_id();
};


class TimerHandler{
public:
	static vector<EventHandler*> event_context;
public:
	TimerHandler();
	virtual ~TimerHandler();
public:
	void add_event(EventHandler *handler);
	void remove_event(EventHandler *handler);
	
};
void event_list(int i);

#endif

timerhandler.cpp:

#include <signal.h>
#include <stdio.h>
#include <sys/time.h>

#include "timerhandler.hpp"

int EventHandler::id=0;
EventHandler::EventHandler(int _second)
{
	id++;
	self_id = id;
	start_time = time(0);
	execute_second = _second;	
}

EventHandler::~EventHandler()
{
}
int EventHandler::get_id()
{
	return self_id;
}
bool EventHandler::operator==(const EventHandler &eh)
{
	if(self_id == eh.self_id ){
		return true;
	}
	return false;
}

void EventHandler::handler()
{
	//cout << "parent" << endl;
}

vector<EventHandler*> TimerHandler::event_context;
TimerHandler::TimerHandler()
{
	signal(SIGALRM,event_list);
	
    struct itimerval timer;
    //间隔时间
    timer.it_interval.tv_sec = 1;//秒数
    timer.it_interval.tv_usec = 0;//微秒
    //开始时间
    timer.it_value.tv_sec = 0;
    timer.it_value.tv_usec = 1;
    setitimer(ITIMER_REAL,&timer,0);//启动计时器
}

TimerHandler::~TimerHandler()
{
}

void event_list(int i)
{
	static int aa = 0;
	cout << aa++ << endl;
	vector<EventHandler*>::iterator it;
	for(it=TimerHandler::event_context.begin();it<TimerHandler::event_context.end();it++){
		cout <<"it->start_time:"<< (*it)->start_time << endl;
		if( ((*it)->execute_second + (*it)->start_time) <= time(0) ){
			cout << "it->self_if:" << (*it)->get_id() << endl;
			(*it)->handler();
			delete (*it);
			TimerHandler::event_context.erase(it);
			it--;
		}
	}
}

void TimerHandler::add_event(EventHandler* handler)
{
	event_context.push_back(handler);
}

void TimerHandler::remove_event(EventHandler* handler)
{
	vector<EventHandler*>::iterator it;
	while(it!=TimerHandler::event_context.end()){
		if( (*it)==handler ){
			delete (*it);
			TimerHandler::event_context.erase(it);
			it--;
		}
		it++;
	}
	
}

class MyHandler: public EventHandler
{
public: 
	MyHandler(int _second);
	virtual ~MyHandler();
	void handler();
};

MyHandler::MyHandler(int _second):EventHandler(_second)
{
}

MyHandler::~MyHandler()
{
}

void MyHandler::handler()
{
	cout << 1234 << endl;
}

int main(){
	
	TimerHandler th;
	MyHandler *m1 = new MyHandler(3);
	th.add_event(m1);
	while(1);
	return 0;
}