timercache.cc

对POSIX timer的面向对象的封装。

#include "TimerCache.h"
#include "ITimer.h"
#include <time.h>
#include <stdio.h>

static int const ERROR_SCOPE = 5;

TimerCache::TimerCache()
{
  pthread_mutex_init(&mutex_m , 0);
}

TimerCache::~TimerCache()
{
  destroyAll();
  pthread_mutex_destroy(&mutex_m);
}

int TimerCache::insert(ITimer * timer , int currentTime , int interval , bool isPeriodical , void * args)
{
  pthread_mutex_lock(&mutex_m);

  Timer * pTimer = new Timer;
  pTimer->timer = timer;
  pTimer->timerId = getTimerId();
  pTimer->isPeriodical = isPeriodical;
  pTimer->interval = interval;
  pTimer->startTime = currentTime;
  pTimer->args = args;

  int endTime = currentTime + interval;
  int index = endTime % LIST_CAPACITY;

  if (timerList_m[index].nextTimer)
  {
    Timer * tmpTimer = timerList_m[index].nextTimer;
    Timer * prevTimer = tmpTimer;
    while (tmpTimer)
    {
      int tmpEndTime = tmpTimer->interval + tmpTimer->startTime;
      if (tmpEndTime < endTime)
      {
        prevTimer = tmpTimer;
        tmpTimer = tmpTimer->next;
      }
      else
      {
        pTimer->next = prevTimer->next;
        prevTimer->next = pTimer;
   
        break;
      }
    }   
  }
  else
  {
    timerList_m[index].nextTimer = pTimer;
  }

  int timerId = pTimer->timerId;

  pthread_mutex_unlock(&mutex_m);
   
  return timerId;
}


int TimerCache::getTimerId()
{
  static int timerId = 0;
  if (timerId < 0x80000000)
  {
    timerId ++;
  }
  else
  {
    timerId = 0;
  }

  return timerId;
}


void TimerCache::destroyAll()
{
  pthread_mutex_lock(&mutex_m);

  for (int i = 0;i < LIST_CAPACITY;i++)
  {
    Timer * pTimer = timerList_m[i].nextTimer;
    while (pTimer)
    {
      Timer * tmpTimer = pTimer;
      pTimer = pTimer->next;

      delete tmpTimer;
      tmpTimer = 0;
    }
  }

  pthread_mutex_unlock(&mutex_m);
}

void TimerCache::expire(int currentTime)
{
  pthread_mutex_lock(&mutex_m);

  int index = currentTime % LIST_CAPACITY;
  Timer * pTimer = timerList_m[index].nextTimer;
  while (pTimer)
  {
    int endTime = pTimer->interval + pTimer->startTime;
	
	timerList_m[index].nextTimer = pTimer->next;	
    if (endTime <= currentTime)
    {
      pTimer->timer->timeout(pTimer->timerId , pTimer->args);
      if (pTimer->isPeriodical)
      {
        pTimer->startTime = currentTime;
		reInsert(pTimer, currentTime);
      }
	  
      delete pTimer;
      pTimer = timerList_m[index].nextTimer;
    }
    else
    {
      break;
    }
  }

  pthread_mutex_unlock(&mutex_m); 
}

void TimerCache::reInsert(Timer * timer , int currentTime)
{
  Timer * pTimer = new Timer;
  pTimer->timer = timer->timer;
  pTimer->timerId = timer->timerId;
  pTimer->isPeriodical = timer->isPeriodical;
  pTimer->interval = timer->interval;
  pTimer->startTime = currentTime;
  pTimer->args = timer->args;
  
  int endTime = currentTime + timer->interval;
  int index = endTime % LIST_CAPACITY;
  
  if (timerList_m[index].nextTimer)
  {
    Timer * tmpTimer = timerList_m[index].nextTimer;
    Timer * prevTimer = tmpTimer;
    while (tmpTimer)
    {
  	  int tmpEndTime = tmpTimer->interval + tmpTimer->startTime;
  	  if (tmpEndTime < endTime)
  	  {
  	    prevTimer = tmpTimer;
  	    tmpTimer = tmpTimer->next;
  	  }
  	  else
  	  {
  	    pTimer->next = prevTimer->next;
  	    prevTimer->next = pTimer;
   
  	    break;
  	  }
    }  
  }
  else
  {
    timerList_m[index].nextTimer = pTimer;
  }

  return;
}


void TimerCache::handleTimeout(int currentTime)
{
  for (int i = 0;i < ERROR_SCOPE;i ++)
  {
    expire(currentTime - i);
  }
}

int TimerCache::remove(int timerId)
{
  pthread_mutex_lock(&mutex_m);

  for (int i = 0;i < LIST_CAPACITY; i++)
  {
    Timer * pTimer = timerList_m[i].nextTimer;
	Timer * prev = pTimer;
	while (pTimer)
	{	  
	  if (pTimer->timerId == timerId)
	  {
        prev->next = pTimer->next;
		
		delete pTimer;
		pTimer = 0;

		pthread_mutex_unlock(&mutex_m);
	    return 0;
	  }
	  prev = pTimer;
	  pTimer = pTimer->next;
	}
  }

  pthread_mutex_unlock(&mutex_m);
  return -1;
}