利用最小堆结构来设计一种定时方案

服务器程序通常管理着众多的定时事件，因此有效地组织这些定时事件，使之能在预期的时间点被触发且不影响服务器的主要逻辑，对于服务器的性能有着至关重要的影响。
本篇主要讨论的是时间堆的设计。在利用最小堆结构来设计定时方案前，我们先来了解一下什么是最小堆。

什么是最小堆

1.概念
最小堆是指每个节点的值都小于或等于其子节点的值的完全二叉树。如下图，就是一个具有6个元素最小堆：

2.最小堆的插入操作
树的基本操作是插入节点和删除节点，最小堆的插入操作步骤如下：
以插入X元素为例
1）在树的下一个空闲位置创建一个空穴，如果X可以放在空穴中而不破坏堆序，则插入完成，否则就执行2）上虑操作；

2）上虑操作即交换空穴和它的父节点上的元素。不断执行该过程，直到X可以被放入空穴，则插入操作完成。

例如向上图的最小堆中插入值为14的元素，步骤如下：

3.最小堆的删除操作
最小堆的删除操作指的是删除其根节点上的元素，并且不破坏堆序性质。最小堆的删除操作步骤如下：
1）首先在根节点出创建一个空穴；

2）因为删除了根节点，现在堆少了一个元素，因此我们可以把堆的最后一个元素X移动到该堆的某个地方。如果X可以被放入空穴，则删除操作完成，否则就执行3）下虑操作；

3）下虑操作即交换空穴和它的两个儿子节点中的较小者。不断执行该过程，直到X可以被放入空穴，则删除操作完成。

例如对上图的最小堆执行删除操作，步骤如下：

4.最小堆的数组表示
由于最小堆是一种完全二叉树，所以我们可以用数组来组织其中的元素。比如上图的最小堆可用可用数组表示如下：

对于数组中的任意一个位置 i 上的元素，其左儿子节点在位置 2i + 1 上，其右儿子节点在位置 2i + 2 上，其父节点则在位置 [ ( i - 1) / 2 ] ( i > 0 ) 上。与用链表来表示堆相比，用数组表示堆不仅节省空间，而且更容易实现堆的插入、删除等操作。

5.最小堆的初始化操作
假设我们已经有一个包含N个元素的数组，现在要把它初始化为一个最小堆。那么最简单的方法是：初始化一个空堆，然后将数组中的每个元素插入该堆中。不过这样做的效率偏低。实际上，我们只需要对数组中的第 0 ~ [ (N - 1) / 2 ] 个元素执行下虑操作，即可确保该数组构成一个最小堆。这是因为对包含N个元素的完全二叉树而言，它具有 [ (N - 1) / 2 ] 个非叶子节点，这些非叶子节点正是该完全二叉树的第 0 ~ [ (N - 1) / 2 ] 个节点。我们只要确保这些非叶子节点构成的子树都具有堆序性质，整个树就具有堆序性质。

方案设计

设计定时器的一种思路如下：
将所有定时器中超时时间最小的一个定时器的超时值作为心搏间隔。这样，一旦心搏函数 tick 被调用，超时时间最小的定时器必然到期，我们就可以在 tick 函数中处理该定时器。然后，再次从剩余的定时器中找出超时时间最小的一个，并将这段最小时间设置为下一次心搏间隔，如此反复，就实现了较为精确的定时。

最小堆很适合处理这种定时方案，我们称用最小堆实现的定时器为时间堆。

一种时间堆的实现如下：

#include <iostream>#include <netinet/in.h>#include <time.h>using std::exception;#define BUFFER_SIZE 64// 前向声明定时器类class heap_timer;// 用户数据，绑定socket和定时器struct client_data{    sockaddr_in address;    int sockfd;    char buf[ BUFFER_SIZE ];    heap_timer* timer;};// 定时器类class heap_timer{public:    heap_timer( int delay )    {        expire = time( NULL ) + delay;    }public:   time_t expire;                    // 定时器生效的绝对时间   void (*cb_func)( client_data* );  // 定时器的回调函数   client_data* user_data;           // 用户数据};// 时间堆类class time_heap{public:    // 构造函数之一，初始化一个大小为cap的空堆    time_heap( int cap ) throw ( std::exception )        : capacity( cap ), cur_size( 0 )    {        array = new heap_timer* [capacity];        if ( ! array )        {            throw std::exception();        }        for( int i = 0; i < capacity; ++i )        {            array[i] = NULL;        }    }    // 构造函数之二，用已有数组来初始化堆    time_heap( heap_timer** init_array, int size, int capacity ) throw ( std::exception )        : cur_size( size ), capacity( capacity )    {        if ( capacity < size )        {            throw std::exception();        }        array = new heap_timer* [capacity];        if ( ! array )        {            throw std::exception();        }        for( int i = 0; i < capacity; ++i )        {            array[i] = NULL;        }        if ( size != 0 )        {            // 初始化堆数组            for ( int i =  0; i < size; ++i )            {                array[ i ] = init_array[ i ];            }            // 对数组中的第 [ (N - 1) / 2 ] ~ 0 个元素执行下虑操作            for ( int i = (cur_size-1)/2; i >=0; --i )            {                percolate_down( i );            }        }    }    // 析构函数，销毁时间堆    ~time_heap()    {        for ( int i =  0; i < cur_size; ++i )        {            delete array[i];        }        delete [] array;     }public:    // 添加目标定时器，时间复杂度为O(logN)    void add_timer( heap_timer* timer ) throw ( std::exception )    {        if( !timer )        {            return;        }        // 当前堆数组容量不够则将其扩大一倍        if( cur_size >= capacity )        {            resize();        }        int hole = cur_size++; // hole是新建空穴的位置        int parent = 0;        // 对从空穴到根节点的路径上的所有节点执行上虑操作        for( ; hole > 0; hole=parent )        {            parent = (hole-1)/2;            if ( array[parent]->expire <= timer->expire )            {                break;            }            array[hole] = array[parent];        }        array[hole] = timer;    }    // 删除目标定时器，时间复杂度为O(1)    void del_timer( heap_timer* timer )    {        if( !timer )        {            return;        }        // 延迟销毁，仅仅将目标定时器的回调函数设置为空        // 这将节省真正删除该定时器造成的开销，但这样做容易使堆数组膨胀        timer->cb_func = NULL;    }    // 获得堆顶的定时器    heap_timer* top() const    {        if ( empty() )        {            return NULL;        }        return array[0];    }    // 删除堆顶的定时器    void pop_timer()    {        if( empty() )        {            return;        }        if( array[0] )        {            delete array[0];            // 将堆顶元素替换为堆数组中最后一个元素，并对它进行下虑操作            array[0] = array[--cur_size];            percolate_down( 0 );        }    }    // 心搏函数，执行一个定时器的时间复杂度为O(1)    void tick()    {        heap_timer* tmp = array[0];        time_t cur = time( NULL );        // 循环处理堆中到时的定时器        while( !empty() )        {            if( !tmp )            {                break;            }            // 定时器未到期则退出循环            if( tmp->expire > cur )            {                break;            }            // 定时器到期则执行堆顶定时器中的任务            if( array[0]->cb_func )            {                array[0]->cb_func( array[0]->user_data );            }            // 弹出堆顶元素，同时设置新的堆顶元素            pop_timer();            tmp = array[0];        }    }    bool empty() const { return cur_size == 0; }private:    // 下虑操作函数    void percolate_down( int hole )    {        heap_timer* temp = array[hole];        int child = 0;        // 当下虑到叶子节点时，循环终止         for ( ; ((hole*2+1) <= (cur_size-1)); hole=child )        {            child = hole*2+1;     // 空穴的左孩子节点            // 选择两个儿子节点中的较小者            if ( (child < (cur_size-1)) && (array[child+1]->expire < array[child]->expire ) )            {                ++child;            }            // 如果空穴比较小的儿子节点大则交换，否则该元素可以放入空穴            if ( array[child]->expire < temp->expire )            {                array[hole] = array[child];            }            else            {                break;            }        }        array[hole] = temp;    }    // 将堆数组容量扩大一倍    // 创建新数组并将容量扩大一倍，初始化新数组，然后将原内容拷贝过来，并释放原空间    void resize() throw ( std::exception )    {        heap_timer** temp = new heap_timer* [2*capacity];        for( int i = 0; i < 2*capacity; ++i )        {            temp[i] = NULL;        }        if ( ! temp )        {            throw std::exception();        }        capacity = 2*capacity;        for ( int i = 0; i < cur_size; ++i )        {            temp[i] = array[i];        }        delete [] array;        array = temp;    }private:    heap_timer** array;     // 堆数组    int capacity;           // 堆数组的容量    int cur_size;           // 堆数组当前包含的元素个数};

---

参考资料：
《Linux高性能服务器编程》 游双